diff --git a/.github/workflows/rust-ci.yml b/.github/workflows/rust-ci.yml index f002eb13b..db27efe18 100644 --- a/.github/workflows/rust-ci.yml +++ b/.github/workflows/rust-ci.yml @@ -32,8 +32,8 @@ jobs: - name: Configure sccache if: github.event_name != 'release' && github.event_name != 'workflow_dispatch' run: | - echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV - echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV + echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV" + echo "RUSTC_WRAPPER=sccache" >> "$GITHUB_ENV" - uses: actions/checkout@v4 @@ -46,7 +46,63 @@ jobs: - name: Run cargo machete run: cargo machete + # Detect available LLVM versions from GitHub releases + detect-llvm-versions: + runs-on: ubuntu-latest + outputs: + matrix: ${{ steps.set-matrix.outputs.matrix }} + steps: + - name: Query LLVM releases and generate matrix + id: set-matrix + run: | + # Query LLVM GitHub releases for available major versions + # We support LLVM 18, 19, 20, 21 + SUPPORTED_VERSIONS="18 19 20 21" + + # Check which versions are available via apt.llvm.org + AVAILABLE_VERSIONS="" + for ver in $SUPPORTED_VERSIONS; do + # Check if the version is available (apt.llvm.org hosts versions 11+) + if curl -s --head "https://apt.llvm.org/llvm.sh" | head -1 | grep -q "200"; then + AVAILABLE_VERSIONS="$AVAILABLE_VERSIONS $ver" + fi + done + + # For now, use a static list of versions we know work + # apt.llvm.org supports versions 11-21 + # Generate JSON matrix + MATRIX='{"include":[' + + # LLVM 18.1 - Ubuntu Noble system package + MATRIX="${MATRIX}{\"llvm_version\":\"18\",\"llvm_env_var\":\"LLVM_SYS_181_PREFIX\",\"cargo_features\":\"--no-default-features --features llvm18\"}" + + # LLVM 19.1 + MATRIX="${MATRIX},{\"llvm_version\":\"19\",\"llvm_env_var\":\"LLVM_SYS_191_PREFIX\",\"cargo_features\":\"--no-default-features --features llvm19\"}" + + # LLVM 20.1 + MATRIX="${MATRIX},{\"llvm_version\":\"20\",\"llvm_env_var\":\"LLVM_SYS_201_PREFIX\",\"cargo_features\":\"--no-default-features --features llvm20\"}" + + # LLVM 21.1 + MATRIX="${MATRIX},{\"llvm_version\":\"21\",\"llvm_env_var\":\"LLVM_SYS_211_PREFIX\",\"cargo_features\":\"--no-default-features --features llvm21\"}" + + MATRIX="${MATRIX}]}" + + echo "Generated matrix: $MATRIX" + echo "matrix=$MATRIX" >> "$GITHUB_OUTPUT" + ubuntu-build-test: + strategy: + fail-fast: false + matrix: + include: + # LLVM 18 - Ubuntu Noble system package + - llvm_version: "18" + llvm_env_var: "LLVM_SYS_181_PREFIX" + cargo_features: "--no-default-features --features llvm18" + # LLVM 21 - Latest from apt.llvm.org + - llvm_version: "21" + llvm_env_var: "LLVM_SYS_211_PREFIX" + cargo_features: "--no-default-features --features llvm21" runs-on: ubuntu-latest needs: [format, machete] steps: @@ -65,32 +121,58 @@ jobs: - name: Configure sccache if: github.event_name != 'release' && github.event_name != 'workflow_dispatch' run: | - echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV - echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV + echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV" + echo "RUSTC_WRAPPER=sccache" >> "$GITHUB_ENV" + + - name: "Cache cargo" + id: cache-cargo + uses: "actions/cache@v4" + with: + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + target/ + save-always: true + key: ${{ runner.os }}-${{runner.arch}}-llvm${{ matrix.llvm_version }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-${{runner.arch}}-llvm${{ matrix.llvm_version }}-cargo- - - name: Install LLVM 18 and Windows cross-compilation tools + - name: Install LLVM ${{ matrix.llvm_version }} and Windows cross-compilation tools run: | wget https://apt.llvm.org/llvm.sh chmod +x llvm.sh - sudo ./llvm.sh 18 - sudo apt-get install -y llvm-18 llvm-18-dev libclang-18-dev - + sudo ./llvm.sh ${{ matrix.llvm_version }} + sudo apt-get install -y llvm-${{ matrix.llvm_version }} llvm-${{ matrix.llvm_version }}-dev libclang-${{ matrix.llvm_version }}-dev + # Install llvm-lib for Windows cross-compilation sudo apt-get install -y mingw-w64 - + # Create symlink for llvm-lib - sudo ln -s /usr/bin/llvm-ar-18 /usr/local/bin/llvm-lib - + sudo ln -sf /usr/bin/llvm-ar-${{ matrix.llvm_version }} /usr/local/bin/llvm-lib + # Verify installation which llvm-lib llvm-lib --version - name: Set LLVM environment variables run: | - echo "LLVM_SYS_181_PREFIX=/usr/lib/llvm-18" >> $GITHUB_ENV - echo "CLANG_PATH=/usr/lib/llvm-18/bin/clang" >> $GITHUB_ENV - echo "PATH=/usr/lib/llvm-18/bin:$PATH" >> $GITHUB_ENV - echo "RUST_BACKTRACE=1" >> $GITHUB_ENV + # See https://gitlab.com/taricorp/llvm-sys.rs/#llvm-compatibility for details + # Set LLVM prefix for llvm-sys crate + echo "${{ matrix.llvm_env_var }}=/usr/lib/llvm-${{ matrix.llvm_version }}" >> "$GITHUB_ENV" + + # llvm-sys needs llvm-config to be findable - create symlink in the LLVM bin dir if not already present + sudo mkdir -p /usr/lib/llvm-${{ matrix.llvm_version }}/bin + sudo ln -sf /usr/bin/llvm-config-${{ matrix.llvm_version }} /usr/lib/llvm-${{ matrix.llvm_version }}/bin/llvm-config || true + + { + echo "CLANG_PATH=/usr/lib/llvm-${{ matrix.llvm_version }}/bin/clang" + echo "PATH=/usr/lib/llvm-${{ matrix.llvm_version }}/bin:$PATH" + echo "RUST_BACKTRACE=1" + } >> "$GITHUB_ENV" + + # Verify llvm-config is accessible + /usr/lib/llvm-${{ matrix.llvm_version }}/bin/llvm-config --version - name: Install build dependencies run: | @@ -98,7 +180,13 @@ jobs: sudo apt-get install -y build-essential - name: Build - run: cargo build --release + run: | + # Build specific packages to avoid workspace feature unification issues + # that cause multiple llvm-sys versions to be compiled + cargo build --release --package openvaf-driver ${{ matrix.cargo_features }} + cargo build --release --package openvaf ${{ matrix.cargo_features }} + cargo build --release --package osdi ${{ matrix.cargo_features }} + cargo build --release --package mir_llvm ${{ matrix.cargo_features }} - name: Show sccache stats if: github.event_name != 'release' && github.event_name != 'workflow_dispatch' @@ -109,7 +197,15 @@ jobs: # run: cargo clippy -- -D warnings - name: Run tests - run: cargo test --release + run: | + # Run tests for specific packages to avoid workspace feature unification issues + cargo test --release --package openvaf-driver ${{ matrix.cargo_features }} + cargo test --release --package openvaf ${{ matrix.cargo_features }} + cargo test --release --package osdi ${{ matrix.cargo_features }} + cargo test --release --package mir_llvm ${{ matrix.cargo_features }} + + - name: Run integration tests + run: cargo test --release --package openvaf --test integration ${{ matrix.cargo_features }} msys2-build-test: strategy: @@ -149,20 +245,34 @@ jobs: uses: actions/cache@v4 with: path: ~/.cache/sccache - key: ${{ runner.os }}-sccache-${{ hashFiles('**/Cargo.lock') }} + key: ${{ runner.os }}-${{ runner.arch }}}-sccache-${{ hashFiles('**/Cargo.lock') }} restore-keys: | - ${{ runner.os }}-sccache- + ${{ runner.os }}-${{ runner.arch }}-sccache- - name: Locate and configure sccache shell: msys2 {0} run: | # export SCCACHE_PATH=$(which sccache) - # echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV - echo "RUSTC_WRAPPER=${SCCACHE_PATH}" >> $GITHUB_ENV + # echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV" + echo "RUSTC_WRAPPER=${SCCACHE_PATH}" >> "$GITHUB_ENV" + + - name: "Cache cargo" + id: cache-cargo + uses: "actions/cache@v4" + with: + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + target/ + save-always: true + key: ${{ runner.os }}-${{ runner.arch }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-${{ runner.arch }}-cargo- - name: Run cargo shell: msys2 {0} - run: cargo build --release + run: cargo build --release --features llvm21 #- name: Show sccache stats # if: github.event_name != 'release' && github.event_name != 'workflow_dispatch' # shell: msys2 {0} @@ -170,18 +280,14 @@ jobs: - name: Run tests shell: msys2 {0} - run: cargo test --release + run: cargo test --release --features llvm21 macos-build-test: strategy: fail-fast: false matrix: - include: - # Intel - - image: macos-15-intel - # ARM64 - - image: macos-15 - - image: macos-14 + # Use default Homebrew LLVM (latest) on all macOS runners + image: [macos-15-intel, macos-15, macos-14] runs-on: ${{ matrix.image }} needs: [format, machete] @@ -192,24 +298,45 @@ jobs: - name: Install dependencies with Homebrew uses: tecolicom/actions-use-homebrew-tools@v1 with: - tools: pkg-config sccache llvm@18 + tools: pkg-config sccache llvm cache: yes - name: Set LLVM environment variables run: | - echo "$(brew --prefix llvm@18)/bin" >> $GITHUB_PATH - echo "LLVM_SYS_181_PREFIX=$(brew --prefix llvm@18)" >> $GITHUB_ENV - echo "RUST_BACKTRACE=1" >> $GITHUB_ENV - echo "RUN_DEV_TESTS=1" >> $GITHUB_ENV + echo "$(brew --prefix llvm)/bin" >> "$GITHUB_PATH" + { + echo "LLVM_SYS_211_PREFIX=$(brew --prefix llvm)" + echo "RUST_BACKTRACE=1" + echo "RUN_DEV_TESTS=1" + } >> "$GITHUB_ENV" - name: sccache setup run: | - # echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV - echo "RUSTC_WRAPPER=$(which sccache)" >> $GITHUB_ENV - + # echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV" + echo "RUSTC_WRAPPER=$(which sccache)" >> "$GITHUB_ENV" + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + + - name: "Cache cargo" + id: cache-cargo + uses: "actions/cache@v4" + with: + path: | + ~/.cargo/bin/ + ~/.cargo/registry/index/ + ~/.cargo/registry/cache/ + ~/.cargo/git/db/ + target/ + save-always: true + key: ${{ runner.os }}-${{runner.arch}}-llvm-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: ${{ runner.os }}-${{runner.arch}}-llvm-cargo- + - name: Build - run: cargo build --release + run: cargo build --release --features llvm21 - name: Run tests - run: cargo test --release + run: cargo test --release --features llvm21 + - name: Run integration tests + run: cargo test --release --features llvm21 --test integration diff --git a/.gitignore b/.gitignore index 5c7bb1cdd..d4e7b3a78 100644 --- a/.gitignore +++ b/.gitignore @@ -36,3 +36,4 @@ markus_notes .env **.swp **.swo +.llvm-version diff --git a/.vscode/launch.json b/.vscode/launch.json index 8a5036f83..daac61d3d 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -19,10 +19,11 @@ "kind": "bin" } }, - // "args": [ "--dump-mir", "--dump-unopt-mir", /* "--dump-ir", */ "simp1.va" ], - "args": [ "--dump-mir", "--dump-unopt-mir", /* "--dump-ir", */ "${workspaceFolder}/integration_tests/HiSIMHV/hisimhv.va" ], + "args": [ "--dump-mir", /*"--dump-unopt-mir", "--dump-ir", */ "simp1.va" ], + // "args": [ "--dump-mir", "--dump-unopt-mir", /* "--dump-ir", */ "${workspaceFolder}/integration_tests/HiSIMHV/hisimhv.va" ], // "args": [ "--dump-mir", "--dump-unopt-mir", /* "--dump-ir", */ "/home/arpadb/rram/hisim/hisimhv.va" ], // "args": [ "--dump-mir", "--dump-unopt-mir", /* "--dump-ir", */ "resistor.va" ], + // "args": [ "--dump-mir", /*"--dump-unopt-mir", "--dump-ir", */ "/home/arpadb/sim/VACASK/devices/opamp.va" ], "cwd": "${workspaceFolder}/..", "env": { "RAYON_NUM_THREADS": "1" diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 000000000..427fe4359 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,203 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project Overview + +OpenVAF-reloaded is a Verilog-A compiler written in Rust that outputs dynamic libraries compatible with the OSDI API (currently version 0.4). The compiler transforms Verilog-A compact device models into optimized native code for circuit simulators like ngspice, SPICE OPUS, and VACASK. + +The project is a fork of Pascal Kuthe's original OpenVAF compiler, maintained by Árpád Bűrmen since 2024, with LLVM 18 support contributed by Kreijstal. + +## Build Commands + +### Prerequisites +- **Rust toolchain**: Install with profile "complete" +- **LLVM 18-21**: Install via package manager: + - macOS: `brew install llvm` (LLVM 21) or `brew install llvm@18` + - Ubuntu: Use apt.llvm.org script (see CI workflow) + +### Building the Compiler (Recommended) +```bash +# Auto-detect LLVM and configure +./configure + +# Build release version +./build.sh --release + +# Build debug version +./build.sh +``` + +### Building the Compiler (Manual) +```bash +# Set LLVM prefix (adjust version as needed) +export LLVM_SYS_211_PREFIX=$(brew --prefix llvm) # macOS LLVM 21 +# Or: export LLVM_SYS_181_PREFIX=/usr/lib/llvm-18 # Ubuntu LLVM 18 + +# Build with explicit feature flag (no default LLVM version) +cargo build --release --features llvm21 --bin openvaf-r +# Or: cargo build --release --features llvm18 --bin openvaf-r +``` + +### Testing +```bash +# Using build script (after ./configure) +./build.sh --test +./build.sh --test --release + +# Or manually with explicit features +cargo test --features llvm21 +cargo test --release --features llvm21 + +# Run all tests including slow ones +RUN_SLOW_TESTS=1 cargo test --features llvm21 + +# Update test snapshots (when you've intentionally changed MIR/IR generation) +UPDATE_EXPECT=1 cargo test --features llvm21 +``` + +**Note**: Some expected test results are in `.snap` files in `openvaf/test_data/`, while others are hard-coded in test source files (e.g., `openvaf/mir_autodiff/src/builder/tests.rs`) and must be updated manually. + +### Python Bindings +```bash +# Build verilogae Python package +cargo xtask verilogae build + +# Run verilogae tests +cargo xtask verilogae test + +# Publish verilogae (with platform flags) +cargo xtask verilogae publish --windows +``` + +## Architecture + +### Compilation Pipeline + +The compiler follows a multi-stage pipeline similar to rustc: + +1. **Lexing & Parsing** (`openvaf/lexer`, `openvaf/parser`) + - Tokenizes Verilog-A source files + - Builds concrete syntax trees using the `rowan` library + +2. **Preprocessing** (`openvaf/preprocessor`) + - Handles `include directives and macro expansion + - Controlled by macro flags passed via CLI + +3. **HIR (High-Level Intermediate Representation)** (`openvaf/hir_def`, `openvaf/hir`, `openvaf/hir_lower`, `openvaf/hir_ty`) + - `hir_def`: Desugars syntax into HIR definitions + - `hir_ty`: Type inference and checking + - `hir_lower`: Lowers HIR to MIR + +4. **MIR (Mid-Level Intermediate Representation)** (`openvaf/mir`, `openvaf/mir_build`, `openvaf/mir_opt`, `openvaf/mir_autodiff`) + - `mir_build`: Constructs MIR from HIR + - `mir_autodiff`: Automatic differentiation for Jacobian computation + - `mir_opt`: MIR-level optimizations + - `mir_reader`: Utilities for reading/debugging MIR + +5. **Code Generation** (`openvaf/mir_llvm`, `openvaf/linker`) + - `mir_llvm`: LLVM IR generation from MIR + - `linker`: Links generated code into `.osdi` dynamic libraries + +6. **OSDI Interface** (`openvaf/osdi`) + - Defines the OSDI 0.4 API structures + - Header files in `openvaf/osdi/header/` + - Handles module descriptors, parameters, Jacobian entries + +### Database Architecture + +Uses `salsa` for incremental compilation: +- **BaseDB** (`openvaf/basedb`): File system, VFS, parsing, linting +- **CompilationDB** (`openvaf/hir`): Extends BaseDB with semantic analysis + +### Key Components + +- **VFS** (`openvaf/vfs`): Virtual file system for source management +- **Syntax** (`openvaf/syntax`): Rowan-based CST with source mapping +- **Target** (`openvaf/target`): Platform-specific codegen configurations +- **Sim Backend** (`openvaf/sim_back`): Simulation-specific transformations +- **Supporting Libraries** (`lib/`): + - `arena`: Arena allocator for HIR/MIR nodes + - `bforest`: B-tree forest data structure + - `typed_indexmap`: Type-safe indexed collections + - `stdx`: Standard library extensions + - `paths`: Path handling utilities + +### Python/FFI Bindings + +- **verilogae** (`verilogae/`): Python package exposing OpenVAF functionality + - `verilogae_ffi`: C/C++ FFI layer (cbindgen/cppbindgen) + - `verilogae_py`: PyO3-based Python bindings + +## Development Workflow + +### Debugging in VS Code +- Copy `.vscode/launch-openvaf-r.json` to `.vscode/launch.json` +- Two configurations available: Linux (CodeLLDB) and Windows (C++ tools) +- Debug builds disable rayon parallelization (`RAYON_NUM_THREADS=1`) for easier debugging + +### Compiler Output Options +```bash +# Dump unoptimized MIR +openvaf-r --dump-unopt-mir model.va + +# Dump optimized MIR +openvaf-r --dump-mir model.va + +# Dump unoptimized LLVM IR +openvaf-r --dump-unopt-ir model.va + +# Dump optimized LLVM IR +openvaf-r --dump-ir model.va +``` + +### Integration Tests +Located in `integration_tests/` with real-world device models (BSIM, MEXTRAM, EKV, etc.). Some models have restrictive licenses and don't affect the OpenVAF binary license. + +Test data snapshots are in `openvaf/test_data/` organized by category: +- `ast/`: Abstract syntax tree snapshots +- `mir/`: MIR snapshots +- `osdi/`: OSDI descriptor snapshots +- `ui/`, `syn_ui/`: User-facing diagnostic snapshots + +## OSDI 0.4 API + +OpenVAF-reloaded generates models with OSDI 0.4 API, which extends 0.3 with: +- Parameter given flags for model/instance parameters +- Jacobian array extraction functions +- Model input lists (node pairs) +- Offset-based Jacobian loading (for harmonic balance) +- Nature/discipline/unit descriptors +- `OSDI_DESCRIPTOR_SIZE` symbol for binary compatibility + +The descriptor structure is backward-compatible with OSDI 0.3 when cast appropriately. + +## Code Organization + +- **openvaf/**: Main compiler crates +- **verilogae/**: Python bindings +- **lib/**: Shared utility libraries +- **integration_tests/**: Real-world test models +- **xtask/**: Build automation tasks +- **melange/**: (Secondary component, minimal documentation) +- **sourcegen/**: Code generation utilities + +## Important Notes + +- The project uses workspace resolver version 2 +- Multi-LLVM support: Use `--features llvm18/llvm19/llvm20/llvm21` (no default - must specify explicitly) +- Use `./configure` to auto-detect LLVM, then `./build.sh` to build +- Custom salsa fork: `git = 'https://github.com/pascalkuthe/salsa'` +- Rust edition: 2021, minimum version varies by crate +- Release builds use `lto = "off"` and `incremental = true` for faster iteration +- Optimized profile (`opt`) available with full LTO for production builds + +### Building with different LLVM versions +```bash +# Auto-detect and configure +./configure + +# Or build with explicit LLVM version +cargo build --release --features llvm18 # LLVM 18 +cargo build --release --features llvm21 # LLVM 21 +``` diff --git a/Cargo.lock b/Cargo.lock index 9dd4b7ae0..32acf2b0b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -166,6 +166,7 @@ dependencies = [ "indexmap 2.10.0", "mini_harness", "parking_lot", + "rustc-hash 2.1.1", "salsa", "stdx", "syntax", @@ -543,6 +544,7 @@ dependencies = [ "once_cell", "ordered-float", "parking_lot", + "rustc-hash 2.1.1", "salsa", "stdx", "syntax", @@ -564,6 +566,7 @@ dependencies = [ "mir", "mir_build", "parking_lot", + "rustc-hash 2.1.1", "salsa", "stdx", "syntax", @@ -722,9 +725,51 @@ dependencies = [ [[package]] name = "llvm-sys" -version = "181.2.0" +version = "181.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d320f9d2723c97d4b78f9190a61ed25cc7cfbe456668c08e6e7dd8e50ceb8500" +checksum = "e24aad69cbdb0c6ebe777262e9e6314dceba0d6e6a2a63e47563ccd293a2eda8" +dependencies = [ + "anyhow", + "cc", + "lazy_static", + "libc", + "regex-lite", + "semver", +] + +[[package]] +name = "llvm-sys" +version = "191.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0ad1fffbdac72a40b55aa58b31aa0efe925e277941b6705f128692b27f1d506" +dependencies = [ + "anyhow", + "cc", + "lazy_static", + "libc", + "regex-lite", + "semver", +] + +[[package]] +name = "llvm-sys" +version = "201.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9bb947e8b79254ca10d496d0798a9ba1287dcf68e50a92b016fec1cc45bef447" +dependencies = [ + "anyhow", + "cc", + "lazy_static", + "libc", + "regex-lite", + "semver", +] + +[[package]] +name = "llvm-sys" +version = "211.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "108b3ad2b2eaf2a561fc74196273b20e3436e4a688b8b44e250d83974dc1b2e2" dependencies = [ "anyhow", "cc", @@ -823,6 +868,7 @@ dependencies = [ "indexmap 2.10.0", "lasso", "list_pool", + "rustc-hash 2.1.1", "smallvec", "stdx", "typed-index-collections", @@ -842,6 +888,7 @@ dependencies = [ "mir", "mir_interpret", "mir_reader", + "rustc-hash 2.1.1", "stdx", "typed-index-collections", "typed_indexmap", @@ -881,7 +928,10 @@ dependencies = [ "base_n", "lasso", "libc", - "llvm-sys", + "llvm-sys 181.3.0", + "llvm-sys 191.1.0", + "llvm-sys 201.0.1", + "llvm-sys 211.0.0", "log", "mir", "target", @@ -892,12 +942,12 @@ dependencies = [ name = "mir_opt" version = "0.0.0" dependencies = [ - "ahash 0.8.12", "bitset", "expect-test", "hashbrown 0.14.5", "mir", "mir_reader", + "rustc-hash 2.1.1", "stdx", "typed-index-collections", "workqueue", @@ -978,7 +1028,10 @@ dependencies = [ "libc", "libloading", "linker", - "llvm-sys", + "llvm-sys 181.3.0", + "llvm-sys 191.1.0", + "llvm-sys 201.0.1", + "llvm-sys 211.0.0", "md5", "mini_harness", "mir_llvm", @@ -1025,7 +1078,6 @@ dependencies = [ name = "osdi" version = "0.0.0" dependencies = [ - "ahash 0.8.12", "base_n", "camino", "expect-test", @@ -1035,7 +1087,10 @@ dependencies = [ "hir_lower", "indexmap 2.10.0", "lasso", - "llvm-sys", + "llvm-sys 181.3.0", + "llvm-sys 191.1.0", + "llvm-sys 201.0.1", + "llvm-sys 211.0.0", "log", "mini_harness", "mir", @@ -1043,6 +1098,7 @@ dependencies = [ "mir_llvm", "paths", "rayon-core", + "rustc-hash 2.1.1", "salsa", "sim_back", "smol_str", @@ -1229,7 +1285,7 @@ checksum = "0a542b0253fa46e632d27a1dc5cf7b930de4df8659dc6e720b647fc72147ae3d" dependencies = [ "countme", "hashbrown 0.14.5", - "rustc-hash", + "rustc-hash 1.1.0", "text-size", ] @@ -1245,6 +1301,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + [[package]] name = "ryu_floating_decimal" version = "0.1.0" @@ -1265,7 +1327,7 @@ dependencies = [ "log", "oorandom", "parking_lot", - "rustc-hash", + "rustc-hash 1.1.0", "salsa-macros", "smallvec", ] @@ -1338,6 +1400,7 @@ dependencies = [ "mir_build", "mir_interpret", "mir_opt", + "rustc-hash 2.1.1", "smol_str", "stdx", "syntax", @@ -1489,8 +1552,8 @@ dependencies = [ name = "typed_indexmap" version = "0.0.0" dependencies = [ - "ahash 0.8.12", "indexmap 2.10.0", + "rustc-hash 2.1.1", ] [[package]] @@ -1546,7 +1609,10 @@ dependencies = [ "lasso", "libloading", "linker", - "llvm-sys", + "llvm-sys 181.3.0", + "llvm-sys 191.1.0", + "llvm-sys 201.0.1", + "llvm-sys 211.0.0", "md5", "mir", "mir_autodiff", @@ -1591,11 +1657,11 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" name = "vfs" version = "0.0.0" dependencies = [ - "ahash 0.8.12", "chardetng", "encoding_rs", "indexmap 2.10.0", "paths", + "rustc-hash 2.1.1", ] [[package]] diff --git a/README.md b/README.md index 15d096671..56714bed1 100644 --- a/README.md +++ b/README.md @@ -52,6 +52,7 @@ Some internals of the OpenVAF compiler are documented in the [internals.md](inte - Natures, disciplines, and the corresponding attributes exposed in OSDI API. - Natures of unknowns and residuals exposed in OSDI descriptor. TODO: switch branches and implicit equations. - $bound_step() fixed. +- Initalization of instance parameters from model defaults now works. # What about binaries? @@ -69,30 +70,78 @@ If the binary is named `openvaf` it comes from the `branches/osdi_0.3` branch an # Building OpenVAF-reloaded -## Setting up the dependencies under Debian Bookworm +## LLVM Version Support Everything was tested under Debian 13. First, install Rust as ordinary user (files will go to `~/.cargo` and `~/.rustup`). -``` +```bash curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh ``` During installation select "Customize installation" and set profile to "complete". -Build LLVM and Clang. Download [LLVM 18.1.8 sources](https://github.com/llvm/llvm-project/releases/tag/llvmorg-18.1.8). Unpack them (this creates directory `llvm-project-llvmorg-18.1.8`) and create a build directory and decide where you want to install LLVM. Type +OpenVAF-reloaded supports multiple LLVM versions from 18 to 21. You can choose which version to use at build time via Cargo features: + +| Feature | LLVM Version | Environment Variable | llvm-sys crate | +|---------|--------------|----------------------|----------------| +| `llvm18` | LLVM 18.1.x | `LLVM_SYS_181_PREFIX` | 181.2.0 | +| `llvm19` | LLVM 19.1.x | `LLVM_SYS_191_PREFIX` | 191.0.0 | +| `llvm20` | LLVM 20.1.x | `LLVM_SYS_201_PREFIX` | 201.0.1 | +| `llvm21` | LLVM 21.1.x | `LLVM_SYS_211_PREFIX` | 211.0.0 | + +**Note:** There is no default LLVM version. You must specify the version explicitly using `--features llvmXX` or use the `./configure` script for auto-detection (see Building section). + +**Ubuntu Noble (24.04)** ships with LLVM 18 as a system package, making it a convenient choice for those platforms. + +**Note:** The llvm-sys crate version follows the pattern `MAJORminor.patch`, where MAJOR is the LLVM major version and minor is the minor version (e.g., 181 = LLVM 18.1, 211 = LLVM 21.1). + +## Setting up the dependencies under Debian/Ubuntu + +### Using LLVM 18 (recommended for Ubuntu Noble) + +On Ubuntu Noble (24.04) or similar, LLVM 18 is available from system packages: +```bash +sudo apt-get install llvm-18 llvm-18-dev libclang-18-dev clang-18 +``` + +Set up the environment: +```bash +export LLVM_SYS_181_PREFIX=/usr/lib/llvm-18 +export PATH=/usr/lib/llvm-18/bin:$PATH +``` + +### Using LLVM 21 + +For LLVM 21 on Ubuntu/Debian, use the official LLVM apt repository: +```bash +wget https://apt.llvm.org/llvm.sh +chmod +x llvm.sh +sudo ./llvm.sh 21 +sudo apt-get install llvm-21 llvm-21-dev libclang-21-dev +``` + +Set up the environment: +```bash +export LLVM_SYS_211_PREFIX=/usr/lib/llvm-21 +export PATH=/usr/lib/llvm-21/bin:$PATH +``` + +### Building LLVM from source (alternative) + +If you need to build LLVM from source, download [LLVM 21.1.6 sources](https://github.com/llvm/llvm-project/releases/tag/llvmorg-21.1.6) (or 18.1.8 for LLVM 18). Unpack them and create a build directory: ``` cmake -S /llvm -B -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="X86;ARM;AArch64" -DLLVM_ENABLE_PROJECTS="llvm;clang;lld" ``` -Enter the build directory and type +Enter the build directory and type: ``` make -j make install ``` -Set up the environment by adding the following to `.bashrc` +Install Rust if not already installed: ``` -export LLVM_SYS_181_PREFIX= -export PATH=/bin:$PATH +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh ``` +During installation select "Customize installation" and set profile to "complete". Make sure the Bash login script is read again (either log out and in again, or type `source ~/.bashrc`) Now you are good to go. @@ -103,33 +152,90 @@ During installation select "Customize installation" and set profile to "complete Install Visual Studio 2022 Community Edition. Make sure you install CMake Tools that come with VS2022 (also installs Ninja). -Build LLVM and Clang. Download [LLVM 18.1.8 sources](https://github.com/llvm/llvm-project/releases/tag/llvmorg-18.1.8) sources (get the .zip file). Unpack the sources (this creates directory `llvm-project-llvmorg-18.1.8`). Create a build directory and decide where you want to install LLVM. +Build LLVM and Clang. Download [LLVM 21.1.6 sources](https://github.com/llvm/llvm-project/releases/tag/llvmorg-21.1.6) sources (get the .zip file). Unpack the sources (this creates directory `llvm-project-llvmorg-21.1.6`). Create a build directory and decide where you want to install LLVM. Start Visual Studio x64 native command prompt. Run CMake, use Ninja as build system. Do not use default (nmake) because for me it always built the Debug version, even when I specified Release. -``` -cmake -G Ninja -S /llvm -B -DCMAKE_INSTALL_PREFIX= -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="X86;ARM;AArch64" -DLLVM_ENABLE_PROJECTS="llvm;clang;lld" +```bash +cmake -G Ninja -S path_to_sources/llvm -B path_to_build_dir -DCMAKE_INSTALL_PREFIX=LLVM_install_directory -DCMAKE_BUILD_TYPE=Release -DLLVM_TARGETS_TO_BUILD="X86;ARM;AArch64" -DLLVM_ENABLE_PROJECTS="llvm;clang;lld" ``` Enter build directory and run Ninja (build and install) -``` +```bash ninja ninja install ``` -Add the LLVM binary directory (`\bin`) to the PATH. Set the `LLVM_SYS_181_PREFIX` environmental variable to ``. +Add the LLVM binary directory (`\bin`) to the PATH. Set the `LLVM_SYS_211_PREFIX` environmental variable to ``. -Restart command prompt. Now you are good to go. +Restart command prompt. Now you are good to go. + +## Setting up the dependencies under macOS + +Install Homebrew if not already installed. + +### Using LLVM 18 +```bash +brew install llvm@18 +export LLVM_SYS_181_PREFIX=$(brew --prefix llvm@18) +export PATH="$(brew --prefix llvm@18)/bin:$PATH" +``` + +### Using LLVM 21 (latest) +```bash +brew install llvm +export LLVM_SYS_211_PREFIX=$(brew --prefix llvm) +export PATH="$(brew --prefix llvm)/bin:$PATH" +``` + +Add the appropriate export commands to `~/.zshrc` (or `~/.bashrc`) to make them permanent. + +Install Rust if not already installed: +```bash +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh +``` + +During installation select "Customize installation" and set profile to "complete". + +Now you are good to go. ## Building -To build the release version (`target/release/openvaf-r`), type +### Quick Start (Recommended) + +The easiest way to build is using the configure script which auto-detects your LLVM installation: + +```bash +./configure # Auto-detect LLVM version +./build.sh --release # Build release version ``` -cargo build --release --bin openvaf-r + +The configure script will: +1. Search for LLVM installations (via environment variables, PATH, or Homebrew on macOS) +2. Select the newest available version (21 > 20 > 19 > 18) +3. Save the configuration to `.llvm-version` + +You can also force a specific version: +```bash +./configure --llvm=18 # Force LLVM 18 ``` -To build the debug version (`target/debug/openvaf-r`), type +### Manual Build + +If you prefer not to use the configure script, specify the LLVM version explicitly: + +```bash +# Set environment variable for your LLVM version +export LLVM_SYS_211_PREFIX=/path/to/llvm-21 # For LLVM 21 +# Or: export LLVM_SYS_181_PREFIX=/path/to/llvm-18 # For LLVM 18 + +# Build with explicit feature flag +cargo build --release --features llvm21 --bin openvaf-r +# Or: cargo build --release --features llvm18 --bin openvaf-r ``` -cargo build --bin openvaf-r + +To build the debug version: +```bash +cargo build --features llvm21 --bin openvaf-r ``` # Debugging OpenVAF-reloaded in Visual Studio Code @@ -141,21 +247,51 @@ The debug configuration disables rayon running the .osdi file build process in p # Running tests with cargo -Pascal has set up a test suite for OpenVAF. To run the tests on the debug version of the binary type +Pascal has set up a test suite for OpenVAF. - cargo test +## Quick Test (Recommended) -To run the tests on the release version type +If you've run `./configure`, use the build script: +```bash +./build.sh --test # Debug tests +./build.sh --test --release # Release tests +``` - cargo test --release +## Manual Testing -By default only fast tests are run. To run all tests set the `RUN_SLOW_TEST` variable to 1, e.g. +To run the tests, specify the LLVM version explicitly: - RUN_SLOW_TESTS=1 cargo test +```bash +# Debug tests +cargo test --features llvm21 -Your changes may fail some tests although they are correct. Consider the case you changed the MIR generator. The expected test results assume MIR is generated the way Pascal did it. If you are sure your changes are correct you can update the expected values (stored in `openvaf/test_data` as files ending with .snap). To do this set the `UPDATE_EXPECT` variable 1, e.g. +# Release tests +cargo test --release --features llvm21 +``` - UPDATE_EXPECT=1 cargo test +By default only fast tests are run. To run all tests set the `RUN_SLOW_TEST` variable to 1, e.g. +```bash +RUN_SLOW_TESTS=1 cargo test +``` + +## Integration Tests + +Integration tests compile real-world Verilog-A models (BSIM, HiSIM, PSP, MEXTRAM, etc.) and verify the generated OSDI libraries. These tests are disabled by default but can be enabled with: +```bash +RUN_DEV_TESTS=1 cargo test --release --features llvm21 --test integration +``` + +Or using the build script: +```bash +RUN_DEV_TESTS=1 ./build.sh --test --release -- --test integration +``` + +## Updating Expected Test Results + +Your changes may fail some tests although they are correct. Consider the case you changed the MIR generator. The expected test results assume MIR is generated the way Pascal did it. If you are sure your changes are correct you can update the expected values (stored in `openvaf/test_data` as files ending with .snap). To do this set the `UPDATE_EXPECT` variable 1, e.g. +```bash +UPDATE_EXPECT=1 cargo test +``` Unfortunately not all expected results are in .snap files. Some are hard-coded in the test sources, e.g. see `openvaf/mir_autodiff/src/builder/tests.rs`. You will have to update these expected values manually. @@ -166,7 +302,9 @@ Kudos to Pascal Kuthe for the great work he did. Geoffrey Coram and Dietmar Warning are authors of several bugfixes included in OpenVAF-reloaded. -Kreijstal ported OpenVAF to LLVM18. +Kreijstal ported OpenVAF to LLVM 18. + +Rob Taylor contributed CI improvements and MACOS support. # Copyright diff --git a/build.sh b/build.sh new file mode 100755 index 000000000..7bab9e9b2 --- /dev/null +++ b/build.sh @@ -0,0 +1,81 @@ +#!/bin/sh +# Build OpenVAF with auto-detected LLVM version +# +# Usage: +# ./build.sh # Debug build +# ./build.sh --release # Release build +# ./build.sh --test # Run tests +# ./build.sh -- # Pass additional args to cargo + +set -e + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +VERSION_FILE="$SCRIPT_DIR/.llvm-version" + +# Parse our arguments +CARGO_CMD="build" +RELEASE="" +EXTRA_ARGS="" +while [ $# -gt 0 ]; do + case "$1" in + --release) + RELEASE="--release" + shift + ;; + --test) + CARGO_CMD="test" + shift + ;; + --clippy) + CARGO_CMD="clippy" + shift + ;; + --) + shift + EXTRA_ARGS="$*" + break + ;; + *) + EXTRA_ARGS="$EXTRA_ARGS $1" + shift + ;; + esac +done + +# Check for configuration +if [ ! -f "$VERSION_FILE" ]; then + echo "Error: Not configured. Run ./configure first." + echo "" + echo "Quick start:" + echo " ./configure # Auto-detect LLVM" + echo " ./build.sh # Build" + exit 1 +fi + +# Load configuration +. "$VERSION_FILE" + +if [ -z "$LLVM_VERSION" ]; then + echo "Error: Invalid configuration. Run ./configure again." + exit 1 +fi + +# Set environment variable for llvm-sys +case "$LLVM_VERSION" in + 18) export LLVM_SYS_181_PREFIX="$LLVM_PREFIX" ;; + 19) export LLVM_SYS_191_PREFIX="$LLVM_PREFIX" ;; + 20) export LLVM_SYS_201_PREFIX="$LLVM_PREFIX" ;; + 21) export LLVM_SYS_211_PREFIX="$LLVM_PREFIX" ;; +esac + +# Add LLVM to PATH if needed +if [ -d "$LLVM_PREFIX/bin" ]; then + export PATH="$LLVM_PREFIX/bin:$PATH" +fi + +echo "Using LLVM $LLVM_VERSION from $LLVM_PREFIX" +echo "" + +# Run cargo +# shellcheck disable=SC2086 +exec cargo $CARGO_CMD $RELEASE --features "llvm$LLVM_VERSION" $EXTRA_ARGS diff --git a/configure b/configure new file mode 100755 index 000000000..65d1fdbc0 --- /dev/null +++ b/configure @@ -0,0 +1,244 @@ +#!/bin/sh +# Auto-detect LLVM version and configure the build +# +# This script detects available LLVM installations and creates a +# .llvm-version file that build.sh uses to select the right features. +# +# Usage: +# ./configure # Auto-detect LLVM +# ./configure --llvm=18 # Force specific version +# ./configure --help # Show help + +set -e + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +VERSION_FILE="$SCRIPT_DIR/.llvm-version" + +usage() { + cat </dev/null 2>&1; then + detected=$("$cmd" --version 2>/dev/null | cut -d. -f1) + if [ "$detected" = "$version" ]; then + echo "$version" + return 0 + fi + fi + done + + # macOS: Check Homebrew + if [ "$(uname)" = "Darwin" ]; then + brew_prefix="${HOMEBREW_PREFIX:-/opt/homebrew}" + if [ ! -d "$brew_prefix" ]; then + brew_prefix="/usr/local" + fi + + # Check versioned formula first (llvm@18, llvm@19, etc.) + if [ -x "$brew_prefix/opt/llvm@$version/bin/llvm-config" ]; then + echo "$version" + return 0 + fi + + # Check default llvm formula + if [ -x "$brew_prefix/opt/llvm/bin/llvm-config" ]; then + detected=$("$brew_prefix/opt/llvm/bin/llvm-config" --version 2>/dev/null | cut -d. -f1) + if [ "$detected" = "$version" ]; then + echo "$version" + return 0 + fi + fi + fi + + return 1 +} + +# Get the LLVM prefix for a version +get_llvm_prefix() { + version=$1 + case "$version" in + 18) env_var="LLVM_SYS_181_PREFIX" ;; + 19) env_var="LLVM_SYS_191_PREFIX" ;; + 20) env_var="LLVM_SYS_201_PREFIX" ;; + 21) env_var="LLVM_SYS_211_PREFIX" ;; + *) return 1 ;; + esac + + # Check environment variable first + eval "prefix=\${$env_var:-}" + if [ -n "$prefix" ] && [ -d "$prefix" ]; then + echo "$prefix" + return 0 + fi + + # Check for llvm-config in PATH + for cmd in "llvm-config-$version" "llvm-config$version"; do + if command -v "$cmd" >/dev/null 2>&1; then + detected=$("$cmd" --version 2>/dev/null | cut -d. -f1) + if [ "$detected" = "$version" ]; then + # Get prefix from llvm-config + "$cmd" --prefix 2>/dev/null + return 0 + fi + fi + done + + # Check default llvm-config + if command -v llvm-config >/dev/null 2>&1; then + detected=$(llvm-config --version 2>/dev/null | cut -d. -f1) + if [ "$detected" = "$version" ]; then + llvm-config --prefix 2>/dev/null + return 0 + fi + fi + + # macOS: Check Homebrew + if [ "$(uname)" = "Darwin" ]; then + brew_prefix="${HOMEBREW_PREFIX:-/opt/homebrew}" + if [ ! -d "$brew_prefix" ]; then + brew_prefix="/usr/local" + fi + + if [ -x "$brew_prefix/opt/llvm@$version/bin/llvm-config" ]; then + echo "$brew_prefix/opt/llvm@$version" + return 0 + fi + + if [ -x "$brew_prefix/opt/llvm/bin/llvm-config" ]; then + detected=$("$brew_prefix/opt/llvm/bin/llvm-config" --version 2>/dev/null | cut -d. -f1) + if [ "$detected" = "$version" ]; then + echo "$brew_prefix/opt/llvm" + return 0 + fi + fi + fi + + return 1 +} + +# Detect available LLVM versions (prefer newer) +detect_llvm() { + for ver in 21 20 19 18; do + if check_llvm_version "$ver" >/dev/null 2>&1; then + echo "$ver" + return 0 + fi + done + return 1 +} + +# Main logic +if [ -n "$FORCE_VERSION" ]; then + case "$FORCE_VERSION" in + 18|19|20|21) + LLVM_VERSION="$FORCE_VERSION" + ;; + *) + echo "Error: Invalid LLVM version '$FORCE_VERSION'" + echo "Supported versions: 18, 19, 20, 21" + exit 1 + ;; + esac +else + echo "Detecting LLVM installation..." + if ! LLVM_VERSION=$(detect_llvm); then + echo "" + echo "Error: No supported LLVM version found." + echo "" + echo "Please install LLVM 18, 19, 20, or 21 and either:" + echo " 1. Add llvm-config to your PATH" + echo " 2. Set LLVM_SYS_XXX_PREFIX environment variable" + echo "" + echo "Installation examples:" + echo " macOS: brew install llvm" + echo " Ubuntu: wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh && sudo ./llvm.sh 21" + echo " Manual: export LLVM_SYS_211_PREFIX=/path/to/llvm" + exit 1 + fi +fi + +LLVM_PREFIX=$(get_llvm_prefix "$LLVM_VERSION") + +echo "" +echo "Detected LLVM $LLVM_VERSION at: $LLVM_PREFIX" +echo "" + +# Write configuration +cat > "$VERSION_FILE" < = iter::Map< iter::Enumerate>, @@ -15,7 +15,7 @@ pub type Iter<'a, I, K, V> = iter::Map< #[repr(transparent)] pub struct TiMap { /// raw set property - pub raw: IndexMap, + pub raw: IndexMap>, _marker: PhantomData I>, } @@ -38,7 +38,10 @@ impl Clone for TiMap { impl Default for TiMap { fn default() -> Self { - Self { raw: IndexMap::default(), _marker: PhantomData } + Self { + raw: IndexMap::with_hasher(BuildHasherDefault::::default()), + _marker: PhantomData, + } } } @@ -75,7 +78,7 @@ impl TiMap { pub fn with_capacity(cap: usize) -> Self { Self { - raw: IndexMap::with_capacity_and_hasher(cap, RandomState::new()), + raw: IndexMap::with_capacity_and_hasher(cap, BuildHasherDefault::::default()), _marker: PhantomData, } } @@ -177,21 +180,24 @@ where } } -impl From> for TiMap { - fn from(raw: IndexMap) -> Self { +impl From>> for TiMap { + fn from(raw: IndexMap>) -> Self { TiMap { raw, _marker: PhantomData } } } impl FromIterator<(K, V)> for TiMap { fn from_iter>(iter: T) -> Self { - Self { raw: iter.into_iter().collect(), _marker: PhantomData } + let mut map = IndexMap::with_hasher(BuildHasherDefault::::default()); + map.extend(iter); + Self { raw: map, _marker: PhantomData } } } -impl AsRef> for IndexMap { +impl AsRef> for IndexMap> { fn as_ref(&self) -> &TiMap { - let ptr = self as *const IndexMap as *const TiMap; + let ptr = + self as *const IndexMap> as *const TiMap; // safety: this is save because of repr(transparent) unsafe { &*ptr } } diff --git a/lib/typed_indexmap/src/set.rs b/lib/typed_indexmap/src/set.rs index 5bacf9402..8405ef751 100644 --- a/lib/typed_indexmap/src/set.rs +++ b/lib/typed_indexmap/src/set.rs @@ -1,17 +1,18 @@ use std::fmt::Debug; -use std::hash::Hash; +use std::hash::{BuildHasherDefault, Hash}; use std::iter; use std::marker::PhantomData; use std::ops::Index; use indexmap::{Equivalent, IndexSet}; +use rustc_hash::FxHasher; pub type Iter<'a, K, V> = iter::Map>, fn((usize, &'a V)) -> (K, &'a V)>; pub struct TiSet { /// raw set property - pub raw: IndexSet, + pub raw: IndexSet>, _marker: PhantomData K>, } @@ -33,14 +34,17 @@ impl Clone for TiSet { impl Default for TiSet { fn default() -> Self { - Self { raw: IndexSet::default(), _marker: PhantomData } + Self { + raw: IndexSet::with_hasher(BuildHasherDefault::::default()), + _marker: PhantomData, + } } } impl TiSet { pub fn with_capacity(cap: usize) -> TiSet { TiSet { - raw: IndexSet::with_capacity_and_hasher(cap, ahash::RandomState::default()), + raw: IndexSet::with_capacity_and_hasher(cap, BuildHasherDefault::::default()), _marker: PhantomData, } } @@ -174,6 +178,8 @@ where V: Eq + Hash, { fn from_iter>(iter: T) -> Self { - Self { raw: iter.into_iter().collect(), _marker: PhantomData } + let mut set = IndexSet::with_hasher(BuildHasherDefault::::default()); + set.extend(iter); + Self { raw: set, _marker: PhantomData } } } diff --git a/melange/core/src/simulation.rs b/melange/core/src/simulation.rs index 6a7d350bf..f834903a8 100644 --- a/melange/core/src/simulation.rs +++ b/melange/core/src/simulation.rs @@ -91,13 +91,13 @@ impl Circuit { eval_ctx: ExprEvalCtxRef, arena: &Arena, config: SimConfig, - ) -> Result { + ) -> Result> { let mut res = self.setup_simulation(config)?; res.prepare_solver(eval_ctx, arena)?; Ok(res) } - pub fn setup_simulation(&self, config: SimConfig) -> Result { + pub fn setup_simulation(&self, config: SimConfig) -> Result> { let model_data: Box> = self .models() .map(|model| { diff --git a/openvaf/basedb/Cargo.toml b/openvaf/basedb/Cargo.toml index 2ab9505b1..4499f9561 100644 --- a/openvaf/basedb/Cargo.toml +++ b/openvaf/basedb/Cargo.toml @@ -35,6 +35,7 @@ typed-index-collections = "3.1" parking_lot = "0.12" indexmap = "2.0" ahash = "0.8" +rustc-hash = "2.0" [dev-dependencies] expect-test = "1.4" diff --git a/openvaf/basedb/src/lints.rs b/openvaf/basedb/src/lints.rs index 97f626912..dd776ec58 100644 --- a/openvaf/basedb/src/lints.rs +++ b/openvaf/basedb/src/lints.rs @@ -1,7 +1,9 @@ use std::fmt::{self, Display, Formatter}; +use std::hash::BuildHasherDefault; use std::sync::Arc; use indexmap::IndexMap; +use rustc_hash::FxHasher; use stdx::{impl_debug_display, impl_idx_from}; use vfs::FileId; @@ -101,7 +103,7 @@ pub struct LintData { /// and `str (lint name) -> LintData` #[derive(Debug, Default, Eq, PartialEq)] pub struct LintRegistry { - lints: IndexMap<&'static str, LintData, ahash::RandomState>, + lints: IndexMap<&'static str, LintData, BuildHasherDefault>, } impl LintRegistry { diff --git a/openvaf/hir_def/Cargo.toml b/openvaf/hir_def/Cargo.toml index b064a3dc2..cb8874444 100644 --- a/openvaf/hir_def/Cargo.toml +++ b/openvaf/hir_def/Cargo.toml @@ -31,6 +31,7 @@ typed-index-collections = "3.1" # Performant collections ahash = "0.8" +rustc-hash = "2.0" indexmap = "2.0" [dev-dependencies] diff --git a/openvaf/hir_def/src/builtin.rs b/openvaf/hir_def/src/builtin.rs index c3a12e939..5729cfb54 100644 --- a/openvaf/hir_def/src/builtin.rs +++ b/openvaf/hir_def/src/builtin.rs @@ -1,7 +1,9 @@ //! Generated by `generate_builtins`, do not edit by hand. -use ahash::RandomState; +use std::hash::BuildHasherDefault; + use indexmap::IndexMap; +use rustc_hash::FxHasher; use syntax::name::{kw, sysfun, Name}; use crate::nameres::ScopeDefItem; @@ -238,7 +240,7 @@ impl BuiltIn { } } } -pub fn insert_builtin_scope(dst: &mut IndexMap) { +pub fn insert_builtin_scope(dst: &mut IndexMap>) { dst.insert(kw::abs, BuiltIn::abs.into()); dst.insert(kw::acos, BuiltIn::acos.into()); dst.insert(kw::acosh, BuiltIn::acosh.into()); @@ -371,7 +373,9 @@ pub fn insert_builtin_scope(dst: &mut IndexMap) dst.insert(kw::slew, BuiltIn::slew.into()); dst.insert(kw::transition, BuiltIn::transition.into()); } -pub fn insert_module_builtin_scope(dst: &mut IndexMap) { +pub fn insert_module_builtin_scope( + dst: &mut IndexMap>, +) { dst.insert(sysfun::mfactor, ParamSysFun::mfactor.into()); dst.insert(sysfun::xposition, ParamSysFun::xposition.into()); dst.insert(sysfun::yposition, ParamSysFun::yposition.into()); diff --git a/openvaf/hir_def/src/nameres.rs b/openvaf/hir_def/src/nameres.rs index 17b1858e4..a49591c3b 100644 --- a/openvaf/hir_def/src/nameres.rs +++ b/openvaf/hir_def/src/nameres.rs @@ -1,3 +1,4 @@ +use std::hash::BuildHasherDefault; use std::ops::{Index, IndexMut}; use std::sync::Arc; @@ -5,6 +6,7 @@ use arena::{Arena, Idx}; use basedb::{AstIdMap, ErasedAstId, FileId}; use indexmap::IndexMap; use once_cell::sync::Lazy; +use rustc_hash::FxHasher; use stdx::{impl_display, impl_from, impl_from_typed}; use syntax::name::{kw, Name}; use syntax::{AstNode, Parse, SourceFile, TextRange}; @@ -271,18 +273,19 @@ impl_from_typed! { for ScopeOrigin } -static BUILTIN_SCOPE: Lazy> = Lazy::new(|| { - let mut scope = IndexMap::default(); - insert_builtin_scope(&mut scope); - scope -}); +static BUILTIN_SCOPE: Lazy>> = + Lazy::new(|| { + let mut scope = IndexMap::default(); + insert_builtin_scope(&mut scope); + scope + }); #[derive(PartialEq, Eq, Clone, Debug)] pub struct Scope { pub origin: ScopeOrigin, parent: Option, - pub children: IndexMap, - pub declarations: IndexMap, + pub children: IndexMap>, + pub declarations: IndexMap>, } impl DefMap { diff --git a/openvaf/hir_lower/Cargo.toml b/openvaf/hir_lower/Cargo.toml index 84c7e7454..af3fffa08 100644 --- a/openvaf/hir_lower/Cargo.toml +++ b/openvaf/hir_lower/Cargo.toml @@ -22,6 +22,7 @@ mir = {version = "0.0.0", path = "../mir" } mir_build = {version = "0.0.0", path = "../mir_build" } ahash = "0.8" +rustc-hash = "2.0" typed-index-collections = "3.1" indexmap = "2.0" lasso = {version = "0.7", features = ["ahash"]} diff --git a/openvaf/hir_lower/src/lib.rs b/openvaf/hir_lower/src/lib.rs index 6dc719f01..1f54f72e6 100644 --- a/openvaf/hir_lower/src/lib.rs +++ b/openvaf/hir_lower/src/lib.rs @@ -1,3 +1,4 @@ +use std::hash::BuildHasherDefault; use std::iter::FilterMap; use ahash::{AHashMap, AHashSet}; @@ -11,6 +12,7 @@ use lasso::Rodeo; use mir::builder::InstBuilder; use mir::{DataFlowGraph, FuncRef, Function, Inst, KnownDerivatives, Param, Unknown, Value}; use mir_build::{FunctionBuilder, FunctionBuilderContext, RetBuilder}; +use rustc_hash::FxHasher; use stdx::packed_option::PackedOption; use stdx::{impl_debug_display, impl_idx_from}; use typed_index_collections::TiVec; @@ -220,13 +222,13 @@ impl_debug_display! { /// A mapping between abstractions used in the MIR and the corresponding /// information from the HIR. This allows the MIR to remain independent of the frontend/HIR -#[derive(Debug, PartialEq, Default, Clone)] +#[derive(Debug, PartialEq, Clone)] pub struct HirInterner { - pub outputs: IndexMap, ahash::RandomState>, + pub outputs: IndexMap, BuildHasherDefault>, pub params: TiMap, pub callbacks: TiSet, pub callback_uses: TiVec>, - pub tagged_reads: IndexMap, + pub tagged_reads: IndexMap>, pub implicit_equations: TiVec, pub lim_state: TiMap>, } @@ -236,6 +238,20 @@ pub type LiveParams<'a> = FilterMap< fn((Param, (&'a ParamKind, &'a Value))) -> Option<(Param, &'a ParamKind, Value)>, >; +impl Default for HirInterner { + fn default() -> Self { + Self { + outputs: IndexMap::with_hasher(BuildHasherDefault::::default()), + params: TiMap::default(), + callbacks: TiSet::default(), + callback_uses: TiVec::default(), + tagged_reads: IndexMap::with_hasher(BuildHasherDefault::::default()), + implicit_equations: TiVec::default(), + lim_state: TiMap::default(), + } + } +} + impl HirInterner { fn contains_ddx( ddx_calls: &mut AHashMap, HybridBitSet)>, diff --git a/openvaf/hir_lower/src/parameters.rs b/openvaf/hir_lower/src/parameters.rs index c19677010..04975ac62 100644 --- a/openvaf/hir_lower/src/parameters.rs +++ b/openvaf/hir_lower/src/parameters.rs @@ -44,6 +44,9 @@ impl CmpOps { } } +// Instance parameter value in eval() is read always from instance, even if it is not given in the instance (bad) +// Instance parameter value in instance setup is read from instance, if not available there then it is read from model +// Storing the default values is performed in setup.rs at MIR->IR translation. impl HirInterner { pub fn insert_param_init( &mut self, @@ -82,6 +85,7 @@ impl HirInterner { let (then_src, else_src) = ctx.make_cond(param_given, |ctx, param_given| { if param_given { + // Builds the if block for the case when param is given if build_stores { let exit = ctx.create_block(); let mut ctx = BodyLoweringCtx { ctx, body: body.borrow(), path: "" }; @@ -107,6 +111,7 @@ impl HirInterner { } param_val } else { + // Builds the else block for the case when param is not given let default_val = ctx.lower_expr_body(body.borrow(), 0); if build_stores { let exit = ctx.create_block(); diff --git a/openvaf/linker/src/lib.rs b/openvaf/linker/src/lib.rs index 7c1c1a533..d0a105bd2 100644 --- a/openvaf/linker/src/lib.rs +++ b/openvaf/linker/src/lib.rs @@ -11,6 +11,16 @@ use camino::{Utf8Path, Utf8PathBuf}; use cc::windows_registry; use target::spec::{LinkerFlavor, Target}; +/// Get the LLVM prefix from environment variables. +/// Checks in order: LLVM 21.1, 20.1, 19.1, 18.1 (newest first). +fn get_llvm_prefix() -> Option { + env::var("LLVM_SYS_211_PREFIX") + .or_else(|_| env::var("LLVM_SYS_201_PREFIX")) + .or_else(|_| env::var("LLVM_SYS_191_PREFIX")) + .or_else(|_| env::var("LLVM_SYS_181_PREFIX")) + .ok() +} + pub fn link( path: Option, target: &Target, @@ -87,6 +97,21 @@ fn linker_with_args<'a>( // this environment variable too in recent versions. cmd.cmd().env("ZERO_AR_DATE", "1"); + // On macOS, we always need to add the SDK sysroot for linking against system libraries + if flavor == LinkerFlavor::Ld64 && target.options.is_like_osx { + // Detect SDK path using xcrun + if let Ok(output) = std::process::Command::new("xcrun").args(["--show-sdk-path"]).output() { + if output.status.success() { + if let Ok(sdk_path) = String::from_utf8(output.stdout) { + let sdk_path = sdk_path.trim(); + if !sdk_path.is_empty() { + cmd.args(["-syslibroot", sdk_path]); + } + } + } + } + } + cmd.add_pre_link_args(target, flavor); add_objects(&mut *cmd); @@ -145,7 +170,17 @@ fn get_linker<'a>( let path = path.unwrap_or_else(|| { if is_msys2_environment() { "gcc".into() + } else if flavor == LinkerFlavor::Ld64 { + // For macOS, prefer LLVM's ld64.lld if available + if let Some(llvm_prefix) = get_llvm_prefix() { + let llvm_lld = PathBuf::from(llvm_prefix).join("bin/ld64.lld"); + if llvm_lld.exists() { + return llvm_lld; + } + } + "ld".into() } else { + // On macOS and Linux, use system ld "ld".into() } }); diff --git a/openvaf/mir/Cargo.toml b/openvaf/mir/Cargo.toml index 7b36c947e..591cd3d02 100644 --- a/openvaf/mir/Cargo.toml +++ b/openvaf/mir/Cargo.toml @@ -16,6 +16,7 @@ list_pool = {version = "0.0.0" , path = "../../lib/list_pool"} typed-index-collections = "3.1" lasso = {version = "0.7", features = ["ahash"]} ahash = "0.8" +rustc-hash = "2.0" bitset = {version = "0.0.0", path = "../../lib/bitset" } typed_indexmap = { version = "0.0.0", path = "../../lib/typed_indexmap" } dot = "0.1.4" diff --git a/openvaf/mir/src/flowgraph/transversal.rs b/openvaf/mir/src/flowgraph/transversal.rs index 9a77e605a..ecb177d9a 100644 --- a/openvaf/mir/src/flowgraph/transversal.rs +++ b/openvaf/mir/src/flowgraph/transversal.rs @@ -120,8 +120,8 @@ impl<'lt> Iterator for Postorder<'lt> { } */ -// Pascal's Postorder was wrong. Did not work for loops. -// This one passses all tests, except for HiSIMHV (has loops that we are trying to fix). +// Pascal's Postorder was wrong. Did not work for loops. +// This one passses all tests, except for HiSIMHV (has loops that we are trying to fix). // TODO: rewrite this without using recursion pub struct Postorder<'a> { cfg: &'a ControlFlowGraph, @@ -136,7 +136,7 @@ impl<'a> Postorder<'a> { cfg, visited: BitSet::new_empty(cfg.data.len()), result: SmallVec::new(), - index: 0, + index: 0, }; po.dfs(root); diff --git a/openvaf/mir/src/serialize.rs b/openvaf/mir/src/serialize.rs index 4dc09fe49..bfe158574 100644 --- a/openvaf/mir/src/serialize.rs +++ b/openvaf/mir/src/serialize.rs @@ -1,8 +1,9 @@ use std::fmt::{self, Display, Write}; +use std::hash::BuildHasherDefault; -use ahash::RandomState; use indexmap::{IndexMap, IndexSet}; use lasso::Rodeo; +use rustc_hash::FxHasher; use crate::{ Block, Const, ControlFlowGraph, Function, Inst, InstructionData, Param, Value, ValueDef, @@ -34,15 +35,15 @@ impl Function { mut param_name: impl FnMut(Param) -> (&'static str, String), outputs: impl Iterator, ) -> String { - let mut inst_map = IndexSet::default(); - let bb_map = cfg + let mut inst_map: IndexSet> = IndexSet::default(); + let bb_map: IndexSet> = cfg .reverse_postorder(self) .map(|bb| { inst_map.extend(self.layout.block_insts(bb)); bb }) .collect(); - let mut val_map: IndexSet = IndexSet::default(); + let mut val_map: IndexSet> = IndexSet::default(); for &inst in inst_map.iter() { if let InstructionData::PhiNode(phi) = &self.dfg.insts[inst] { val_map.extend(self.dfg.phi_edges(phi).map(|(_, val)| val)) @@ -99,9 +100,9 @@ impl Function { struct Serializer<'a> { cfg: &'a ControlFlowGraph, func: &'a Function, - inst_map: &'a IndexSet, - bb_map: &'a IndexSet, - val_map: &'a IndexSet, + inst_map: &'a IndexSet>, + bb_map: &'a IndexSet>, + val_map: &'a IndexSet>, inputs: &'a IndexMap<&'static str, Vec<(String, usize)>>, intern: &'a Rodeo, buf: String, diff --git a/openvaf/mir/src/validation.rs b/openvaf/mir/src/validation.rs index a670bea0d..9f8b86875 100644 --- a/openvaf/mir/src/validation.rs +++ b/openvaf/mir/src/validation.rs @@ -7,6 +7,7 @@ impl Function { cfg.compute(self); let mut dom_tree = DominatorTree::default(); dom_tree.compute(self, &cfg, true, false, true); + for &bb in dom_tree.cfg_postorder() { for (seq_num, inst) in self.layout.block_insts(bb).enumerate() { let mut valid_inst = true; @@ -27,6 +28,10 @@ impl Function { let edge_def = self.dfg.value_def(edge_val); if let Some(arg_def) = edge_def.inst() { if let Some(edge_val_bb) = self.layout.inst_block(arg_def) { + // if !dom_tree.dominates(edge_bb, edge_val_bb) { + // eprintln!("{edge_val} doesn't dominate use ({edge_val_bb} !dom {edge_bb})"); + // valid_inst = false; + // } assert!( dom_tree.dominates(edge_bb, edge_val_bb), "{edge_val} doesn't dominate use ({edge_val_bb} !dom {edge_bb})" @@ -49,6 +54,10 @@ impl Function { .unwrap(); assert!(arg_seq_num < seq_num, "{arg} doesn't dominate use"); } else { + // if !dom_tree.dominates(bb, arg_bb) { + // eprintln!("{arg} doesn't dominate use ({arg_bb} !dom {bb})"); + // valid_inst = false; + // } assert!( dom_tree.dominates(bb, arg_bb), "{arg} doesn't dominate use ({arg_bb} !dom {bb})" diff --git a/openvaf/mir_autodiff/Cargo.toml b/openvaf/mir_autodiff/Cargo.toml index 42382dfcf..5aa8ff9fd 100644 --- a/openvaf/mir_autodiff/Cargo.toml +++ b/openvaf/mir_autodiff/Cargo.toml @@ -21,6 +21,7 @@ arena = { version = "0.0.0", path = "../../lib/arena" } indexmap = "2.0" typed-index-collections = "3.1" ahash = "0.8" +rustc-hash = "2.0" [dev-dependencies] expect-test = "1.4" diff --git a/openvaf/mir_autodiff/src/builder.rs b/openvaf/mir_autodiff/src/builder.rs index 0d608baa5..f14ad5b94 100644 --- a/openvaf/mir_autodiff/src/builder.rs +++ b/openvaf/mir_autodiff/src/builder.rs @@ -1,3 +1,5 @@ +use std::collections::HashMap; +use std::hash::BuildHasherDefault; use std::ops::Range; use ahash::AHashMap; @@ -8,6 +10,7 @@ use mir::{ Block, Function, Inst, InstructionData, Opcode, SourceLoc, Unknown, Value, F_LOG10_E, F_ONE, F_TWO, F_ZERO, }; +use rustc_hash::FxHasher; use stdx::iter::zip; use stdx::packed_option::{PackedOption, ReservedValue}; @@ -22,8 +25,8 @@ pub fn build_derivatives( intern: &mut DerivativeIntern, live_derivatives: &LiveDerivatives, post_order: &[Block], -) -> AHashMap<(Value, Unknown), Value> { - let derivative_values: AHashMap<(Value, Unknown), Value> = +) -> HashMap<(Value, Unknown), Value, BuildHasherDefault> { + let derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault> = intern.unknowns.iter_enumerated().map(|(unknown, &val)| ((val, unknown), F_ONE)).collect(); let mut known_values = BitSet::new_empty(func.dfg.num_values()); @@ -56,7 +59,7 @@ pub(crate) struct DerivativeBuilder<'a, 'u> { live_derivatives: &'a LiveDerivatives, intern: &'a mut DerivativeIntern<'u>, - derivative_values: AHashMap<(Value, Unknown), Value>, + derivative_values: HashMap<(Value, Unknown), Value, BuildHasherDefault>, known_values: BitSet, dst: (Inst, SourceLoc), new_block: Option, @@ -320,6 +323,59 @@ impl<'a, 'u> DerivativeBuilder<'a, 'u> { self.derivative_values.insert((prev_order, unknown), val); } + // Before calling insert_conversions, ensure any derivative values it will + // access that are defined in calculate_derivative_block have phi nodes. + // This fixes dominance violations when chain rule conversions reference + // intermediate derivatives computed in the conditional block. + if let Some(conversion) = self.live_derivatives.conversions.get(&inst) { + // TODO: maybe make values_to_phi a set for faster contains() + let values_to_phi: Vec<_> = conversion + .iter() + .flat_map(|chain_rule| { + let outer = + self.derivative_of(chain_rule.val, chain_rule.outer_derivative); + let inner = self.derivative_of( + chain_rule.inner_derivative.0, + chain_rule.inner_derivative.1, + ); + [outer, inner] + }) + .filter(|&val| { + if val == F_ZERO { + return false; + } + // Check if value is defined in calculate_derivative_block + if let Some(def_inst) = self.func.dfg.value_def(val).inst() { + self.func.layout.inst_block(def_inst) + == Some(calculate_derivative_block) + } else { + false + } + }) + .collect(); + + // Create phis for these values and update derivative_values + // We need to find the keys that map to these values + let entries_to_update: Vec<_> = self + .derivative_values + .iter() + .filter_map(|(&key, &val)| { + if values_to_phi.contains(&val) { + Some((key, val)) + } else { + None + } + }) + .collect(); + + for (key, val) in entries_to_update { + let checked_val = self + .ins() + .phi(&[(old_block, F_ZERO), (calculate_derivative_block, val)]); + self.derivative_values.insert(key, checked_val); + } + } + self.insert_conversions(inst); self.new_block.take(); } @@ -448,7 +504,7 @@ impl<'a, 'u> DerivativeBuilder<'a, 'u> { fn derivative_of_( intern: &DerivativeIntern, - derivative_values: &AHashMap<(Value, Unknown), Value>, + derivative_values: &HashMap<(Value, Unknown), Value, BuildHasherDefault>, mut val: Value, derivative: Derivative, ) -> Value { diff --git a/openvaf/mir_autodiff/src/lib.rs b/openvaf/mir_autodiff/src/lib.rs index 1de40e026..ccd29d988 100644 --- a/openvaf/mir_autodiff/src/lib.rs +++ b/openvaf/mir_autodiff/src/lib.rs @@ -4,12 +4,15 @@ mod live_derivatives; mod postorder; mod subgraph; -use ahash::AHashMap; +use std::collections::HashMap; +use std::hash::BuildHasherDefault; + pub use builder::build_derivatives; pub use live_derivatives::LiveDerivatives; use mir::{ DataFlowGraph, DominatorTree, Function, Inst, InstructionData, KnownDerivatives, Opcode, Value, }; +use rustc_hash::FxHasher; use crate::intern::{Derivative, DerivativeIntern}; @@ -18,7 +21,7 @@ pub fn auto_diff( dom_tree: &DominatorTree, derivatives: &KnownDerivatives, extra_derivatives: &[(Value, mir::Unknown)], -) -> AHashMap<(Value, mir::Unknown), Value> { +) -> HashMap<(Value, mir::Unknown), Value, BuildHasherDefault> { let func = func.as_mut(); let mut intern = DerivativeIntern::new(derivatives); let live_derivative = LiveDerivatives::build(func, &mut intern, extra_derivatives, dom_tree); diff --git a/openvaf/mir_autodiff/src/subgraph.rs b/openvaf/mir_autodiff/src/subgraph.rs index d94b8a47a..107b03723 100644 --- a/openvaf/mir_autodiff/src/subgraph.rs +++ b/openvaf/mir_autodiff/src/subgraph.rs @@ -1,8 +1,10 @@ +use std::hash::BuildHasherDefault; use std::mem::{replace, take}; use bitset::{BitSet, HybridBitSet, SparseBitSet}; use indexmap::IndexMap; use mir::{Block, DominatorTree, Function, Inst, Opcode, Unknown, Value, ValueDef}; +use rustc_hash::FxHasher; use crate::intern::{Derivative, DerivativeInfo, DerivativeIntern}; use crate::{zero_derivative, ChainRule, LiveDerivatives}; @@ -24,7 +26,7 @@ struct SubGraphExplorer<'a, 'b> { saved_insts: i32, completed_subgraphs: Vec>, - derivative_map: IndexMap, + derivative_map: IndexMap>, } impl<'a, 'b> SubGraphExplorer<'a, 'b> { diff --git a/openvaf/mir_llvm/Cargo.toml b/openvaf/mir_llvm/Cargo.toml index 32e930b11..79bbb3d48 100644 --- a/openvaf/mir_llvm/Cargo.toml +++ b/openvaf/mir_llvm/Cargo.toml @@ -8,9 +8,18 @@ license = "GPL-3.0" [lib] doctest = false +[features] +# No default - user must specify --features llvm18/llvm19/llvm20/llvm21 +llvm18 = ["dep:llvm-sys-181"] +llvm19 = ["dep:llvm-sys-191"] +llvm20 = ["dep:llvm-sys-201"] +llvm21 = ["dep:llvm-sys-211"] [dependencies] -llvm-sys = {version="181.1.1", features=["prefer-dynamic"]} +llvm-sys-181 = { package = "llvm-sys", version = "181.2.0", features = ["prefer-dynamic"], optional = true } +llvm-sys-191 = { package = "llvm-sys", version = "191.0.0", features = ["prefer-dynamic"], optional = true } +llvm-sys-201 = { package = "llvm-sys", version = "201.0.1", features = ["prefer-dynamic"], optional = true } +llvm-sys-211 = { package = "llvm-sys", version = "211.0.0", features = ["prefer-dynamic"], optional = true } #target-lexicon = "0.12" mir = { version = "0.0.0", path = "../mir" } target = { version = "0.0.0", path = "../target" } diff --git a/openvaf/mir_llvm/src/context.rs b/openvaf/mir_llvm/src/context.rs index 303e8b0db..363bf2fd5 100644 --- a/openvaf/mir_llvm/src/context.rs +++ b/openvaf/mir_llvm/src/context.rs @@ -4,7 +4,9 @@ use std::ptr::NonNull; use ahash::AHashMap; use lasso::{Rodeo, Spur}; -use libc::{c_char, c_uint}; +use libc::c_char; +#[cfg(feature = "llvm18")] +use libc::c_uint; use llvm_sys::bit_reader::LLVMParseBitcodeInContext2; //use llvm_sys::LLVMBool; // For False, if applicable use llvm_sys::core::{LLVMCreateMemoryBufferWithMemoryRange, LLVMGetNamedFunction}; @@ -107,6 +109,8 @@ impl<'a, 'll> CodegenCx<'a, 'll> { // assert!(!val.contains(&b'\0')); // val.push(b'\0'); + // LLVM 18 uses LLVMConstStringInContext, LLVM 19+ uses LLVMConstStringInContext2 + #[cfg(feature = "llvm18")] let val = unsafe { llvm_sys::core::LLVMConstStringInContext( NonNull::from(self.llcx).as_ptr(), @@ -115,6 +119,15 @@ impl<'a, 'll> CodegenCx<'a, 'll> { 0, ) }; + #[cfg(any(feature = "llvm19", feature = "llvm20", feature = "llvm21"))] + let val = unsafe { + llvm_sys::core::LLVMConstStringInContext2( + NonNull::from(self.llcx).as_ptr(), + val.as_ptr() as *const c_char, + val.len(), + 0, + ) + }; let sym = self.generate_local_symbol_name("str"); let ty = self.val_ty(unsafe { &*val }); let global = self diff --git a/openvaf/mir_llvm/src/intrinsics.rs b/openvaf/mir_llvm/src/intrinsics.rs index d5cc92bb9..f04fd44af 100644 --- a/openvaf/mir_llvm/src/intrinsics.rs +++ b/openvaf/mir_llvm/src/intrinsics.rs @@ -97,7 +97,7 @@ impl<'a, 'll> CodegenCx<'a, 'll> { variadic: bool, ) -> (&'ll Type, &'ll Value) { let fn_ty = - if variadic { self.ty_variadic_func(&[], ret) } else { self.ty_func(args, ret) }; + if variadic { self.ty_variadic_func(args, ret) } else { self.ty_func(args, ret) }; let f = self.get_func_by_name(name).unwrap_or_else(|| self.declare_ext_fn(name, fn_ty)); self.intrinsics.borrow_mut().insert(name, (fn_ty, f)); (fn_ty, f) diff --git a/openvaf/mir_llvm/src/lib.rs b/openvaf/mir_llvm/src/lib.rs index 806a15670..f300c979b 100644 --- a/openvaf/mir_llvm/src/lib.rs +++ b/openvaf/mir_llvm/src/lib.rs @@ -1,3 +1,13 @@ +// Re-export the correct llvm-sys version based on feature flags +#[cfg(feature = "llvm18")] +extern crate llvm_sys_181 as llvm_sys; +#[cfg(feature = "llvm19")] +extern crate llvm_sys_191 as llvm_sys; +#[cfg(feature = "llvm20")] +extern crate llvm_sys_201 as llvm_sys; +#[cfg(feature = "llvm21")] +extern crate llvm_sys_211 as llvm_sys; + use std::error::Error; use std::ffi::{CStr, CString}; use std::fmt::{self, Debug, Display, Formatter}; @@ -82,7 +92,8 @@ impl Drop for LLVMString { } use llvm_sys::core::{LLVMGetDiagInfoDescription, LLVMGetDiagInfoSeverity}; -use llvm_sys::target_machine::{LLVMCodeGenOptLevel, LLVMGetHostCPUFeatures, LLVMGetHostCPUName}; +pub use llvm_sys::target_machine::LLVMCodeGenOptLevel; +use llvm_sys::target_machine::{LLVMGetHostCPUFeatures, LLVMGetHostCPUName}; use target::spec::Target; mod builder; @@ -98,6 +109,7 @@ mod tests; pub use builder::{Builder, BuilderVal, MemLoc}; pub use callbacks::{BuiltCallbackFun, CallbackFun, InlineCallbackBuilder}; pub use context::CodegenCx; + pub struct LLVMBackend<'t> { target: &'t Target, target_cpu: String, diff --git a/openvaf/mir_opt/Cargo.toml b/openvaf/mir_opt/Cargo.toml index 53c21086e..64f9fb59c 100644 --- a/openvaf/mir_opt/Cargo.toml +++ b/openvaf/mir_opt/Cargo.toml @@ -17,8 +17,8 @@ workqueue = {version = "0.0.0", path = "../../lib/workqueue" } bitset = {version = "0.0.0", path = "../../lib/bitset" } typed-index-collections = "3.1" -ahash = "0.8" hashbrown = {version = "0.14", features = ["raw"]} +rustc-hash = "2.1" [dev-dependencies] expect-test = "1.4" diff --git a/openvaf/mir_opt/src/global_value_numbering.rs b/openvaf/mir_opt/src/global_value_numbering.rs index f96fd9e85..4d8ccafa6 100644 --- a/openvaf/mir_opt/src/global_value_numbering.rs +++ b/openvaf/mir_opt/src/global_value_numbering.rs @@ -1,15 +1,15 @@ use std::cmp::Ordering; -use std::hash::{BuildHasher, Hash, Hasher}; +use std::hash::{BuildHasher, BuildHasherDefault, Hash, Hasher}; use std::mem::{swap, ManuallyDrop}; use std::ops::{Index, IndexMut}; -use ahash::RandomState; use bitset::{BitSet, HybridBitSet}; use hashbrown::raw::RawTable; use mir::{ Block, DominatorTree, FuncRef, Function, Inst, InstructionData, Opcode, Value, ValueDef, ValueList, }; +use rustc_hash::FxHasher; use stdx::packed_option::PackedOption; use stdx::{impl_idx_from, impl_idx_math}; use typed_index_collections::TiVec; @@ -188,7 +188,7 @@ impl GVNExpression { } } - fn hash(&self, state: &RandomState, func: &Function) -> u64 { + fn hash(&self, state: &BuildHasherDefault, func: &Function) -> u64 { let mut hasher = state.build_hasher(); self.opcode.hash(&mut hasher); match self.opcode { @@ -354,7 +354,7 @@ struct ClassMap { inst_class: TiVec>, expr_class: RawTable, classes: TiVec, - state: RandomState, + state: BuildHasherDefault, } impl ClassMap { diff --git a/openvaf/mir_opt/src/split_tainted.rs b/openvaf/mir_opt/src/split_tainted.rs index 2b3d6ac0e..42434fbb5 100644 --- a/openvaf/mir_opt/src/split_tainted.rs +++ b/openvaf/mir_opt/src/split_tainted.rs @@ -2,17 +2,17 @@ use bitset::{BitSet, HybridBitSet, SparseBitMatrix}; use mir::{Block, ControlFlowGraph, DominatorTree, Function, Inst, InstructionData, Value}; use std::collections::{HashMap, HashSet}; -// Constructs +// Constructs // - a map from block to corresponding top level loop header block -// - a map from top level loop header block to all blocks -// within that loop (including the header block). +// - a map from top level loop header block to all blocks +// within that loop (including the header block). pub fn loop_block_map( - func: &Function, + func: &Function, cfg: &ControlFlowGraph, ) -> (HashMap>, HashMap) { let mut loop_blocks_map: HashMap> = HashMap::new(); let mut header_map: HashMap = HashMap::new(); - + // Reverse postordering let mut rpo = cfg.reverse_postorder(func); rpo.reset(); @@ -33,9 +33,9 @@ pub fn loop_block_map( loop_blocks_map.insert(bb, Vec::new()); } } - _ => (), + _ => (), } - // Did we reach end of the loop + // Did we reach end of the loop if Some(bb) == tail { // No head, no tail head = None; @@ -47,7 +47,10 @@ pub fn loop_block_map( // Add to header_map header_map.insert(bb, head.unwrap()); // Add to vector of loop blocks - loop_blocks_map.get_mut(&head.unwrap()).expect("Blocks vector not in map.").push(bb); + loop_blocks_map + .get_mut(&head.unwrap()) + .expect("Blocks vector not in map.") + .push(bb); } } } @@ -72,7 +75,7 @@ pub fn propagate_taint( cfg, bb_queue: Vec::new(), }; - + // Taint all instructions that use the values in tainted list for val in tainted { for use_ in func.dfg.uses(val) { @@ -81,7 +84,6 @@ pub fn propagate_taint( } } - solver.solve(); } @@ -148,15 +150,15 @@ impl TaintSolver<'_> { } fn solve(&mut self) { - // Construct a map from block to the header block of the outermost loop. - // If a block is not in that map it does not belong to any loop. + // Construct a map from block to the header block of the outermost loop. + // If a block is not in that map it does not belong to any loop. let (loop_blocks_map, header_map) = loop_block_map(self.func, self.cfg); // Tainted loops let mut tainted_loops: HashSet = HashSet::new(); // While there are instructions in the queue - while self.inst_queue.len()>0 { + while self.inst_queue.len() > 0 { // Propagate taint from tainted instructions onward while let Some(inst) = self.inst_queue.pop() { match self.func.dfg.insts[inst] { @@ -182,11 +184,11 @@ impl TaintSolver<'_> { _ => (), } - // TODO: If instruction is in a loop and that loop is not tainted yet, - // taint all blocks of the outermost loop that contains it. + // TODO: If instruction is in a loop and that loop is not tainted yet, + // taint all blocks of the outermost loop that contains it. // Need a map block -> header block of the outermost loop containing that block - // A loop is identified by its header block. - + // A loop is identified by its header block. + // Find all uses of an instruction, taint instructions that correspond to uses for use_ in self.func.dfg.inst_uses(inst) { let user = self.func.dfg.use_to_operand(use_).0; @@ -196,12 +198,16 @@ impl TaintSolver<'_> { // Propagate taint from tainted instructions to loops holding those instructions // Collect all loop header blocks - let hdrs: HashSet = self.tainted_insts.iter().filter_map(|inst| { - if let Some(bb) = self.func.layout.inst_block(inst) { - return header_map.get(&bb).cloned(); - } - return None; - }).collect(); + let hdrs: HashSet = self + .tainted_insts + .iter() + .filter_map(|inst| { + if let Some(bb) = self.func.layout.inst_block(inst) { + return header_map.get(&bb).cloned(); + } + return None; + }) + .collect(); // Taint all loops // This adds new instructions to inst_queue for hdr in hdrs { @@ -222,8 +228,8 @@ impl TaintSolver<'_> { } } // Repeat until inst_queue is empty - } - } + } + } } pub fn propagate_direct_taint( diff --git a/openvaf/openvaf-driver/Cargo.toml b/openvaf/openvaf-driver/Cargo.toml index c5a2ea9d6..aa97951c7 100644 --- a/openvaf/openvaf-driver/Cargo.toml +++ b/openvaf/openvaf-driver/Cargo.toml @@ -11,9 +11,16 @@ path = "src/main.rs" doctest = false test = false +[features] +# No default - user must specify --features llvm18/llvm19/llvm20/llvm21 +llvm18 = ["openvaf/llvm18"] +llvm19 = ["openvaf/llvm19"] +llvm20 = ["openvaf/llvm20"] +llvm21 = ["openvaf/llvm21"] + [dependencies] -openvaf = { version = "0.1.2", path = "../openvaf" } +openvaf = { version = "0.1.2", path = "../openvaf", default-features = false } clap = "=4.3" directories-next = "2" diff --git a/openvaf/openvaf/Cargo.toml b/openvaf/openvaf/Cargo.toml index c9a858d0e..ff7f8568d 100644 --- a/openvaf/openvaf/Cargo.toml +++ b/openvaf/openvaf/Cargo.toml @@ -8,16 +8,26 @@ license = "GPL-3.0" [lib] doctest = false +[features] +# No default - user must specify --features llvm18/llvm19/llvm20/llvm21 +llvm18 = ["dep:llvm-sys-181", "mir_llvm/llvm18", "osdi/llvm18"] +llvm19 = ["dep:llvm-sys-191", "mir_llvm/llvm19", "osdi/llvm19"] +llvm20 = ["dep:llvm-sys-201", "mir_llvm/llvm20", "osdi/llvm20"] +llvm21 = ["dep:llvm-sys-211", "mir_llvm/llvm21", "osdi/llvm21"] + [dependencies] tokens = { version = "0.0.0", path = "../tokens" } basedb = { version = "0.0.0", path = "../basedb" } sim_back = { version = "0.0.0", path = "../sim_back" } -osdi = { version = "0.0.0", path = "../osdi" } +osdi = { version = "0.0.0", path = "../osdi", default-features = false } #llvm = { version = "0.0.0", path = "../llvm" } -llvm-sys = "181.1.1" -mir_llvm = { version = "0.0.0", path = "../mir_llvm" } +llvm-sys-181 = { package = "llvm-sys", version = "181.2.0", optional = true } +llvm-sys-191 = { package = "llvm-sys", version = "191.0.0", optional = true } +llvm-sys-201 = { package = "llvm-sys", version = "201.0.1", optional = true } +llvm-sys-211 = { package = "llvm-sys", version = "211.0.0", optional = true } +mir_llvm = { version = "0.0.0", path = "../mir_llvm", default-features = false } hir = { version = "0.0.0", path = "../hir" } target = { version = "0.0.0", path = "../target" } linker = { version = "0.0.0", path = "../linker" } diff --git a/openvaf/openvaf/src/lib.rs b/openvaf/openvaf/src/lib.rs index bc889f38f..a2bb15f28 100644 --- a/openvaf/openvaf/src/lib.rs +++ b/openvaf/openvaf/src/lib.rs @@ -1,3 +1,13 @@ +// Re-export the correct llvm-sys version based on feature flags +#[cfg(feature = "llvm18")] +extern crate llvm_sys_181 as llvm_sys; +#[cfg(feature = "llvm19")] +extern crate llvm_sys_191 as llvm_sys; +#[cfg(feature = "llvm20")] +extern crate llvm_sys_201 as llvm_sys; +#[cfg(feature = "llvm21")] +extern crate llvm_sys_211 as llvm_sys; + use std::fs::{create_dir_all, remove_file}; use std::io::Write; use std::time::Instant; diff --git a/openvaf/openvaf/tests/integration.rs b/openvaf/openvaf/tests/integration.rs index 6298bf782..6c402cde8 100644 --- a/openvaf/openvaf/tests/integration.rs +++ b/openvaf/openvaf/tests/integration.rs @@ -4,9 +4,8 @@ use std::path::Path; use camino::Utf8Path; use expect_test::expect_file; use float_cmp::assert_approx_eq; -use llvm_sys::target_machine::LLVMCodeGenOptLevel; use mini_harness::{harness, Result}; -use openvaf::{CompilationDestination, CompilationTermination}; +use openvaf::{CompilationDestination, CompilationTermination, LLVMCodeGenOptLevel}; use stdx::{ignore_dev_tests, openvaf_test_data, project_root}; use target::spec::Target; diff --git a/openvaf/openvaf/tests/load/mod.rs b/openvaf/openvaf/tests/load/mod.rs index beb398b3b..db519f78e 100644 --- a/openvaf/openvaf/tests/load/mod.rs +++ b/openvaf/openvaf/tests/load/mod.rs @@ -452,24 +452,19 @@ impl Debug for OsdiDescriptor { osdi_str(node.units), osdi_str(node.residual_units) ); - wn!( - "residual {} {} {} {}", - node.resist_residual_off, - node.react_residual_off, - node.resist_limit_rhs_off, - node.react_limit_rhs_off - ); + // Residual offsets are arch-specific (depend on struct alignment) + // so we omit them from snapshots to allow cross-platform testing } for matrix_entry in self.matrix_entries() { let hi = self.nodes()[matrix_entry.nodes.node_1 as usize].name; let lo = self.nodes()[matrix_entry.nodes.node_2 as usize].name; wn!( - "jacobian ({}, {}) {:?} react_ptr = {}", + "jacobian ({}, {}) {:?}", osdi_str(hi), osdi_str(lo), JacobianFlags::from_bits(matrix_entry.flags).unwrap(), - matrix_entry.react_ptr_off, ); + // react_ptr offset is arch-specific, omitted for cross-platform testing } for OsdiNodePair { node_1, node_2 } in self.collapsible() { let hi = self.nodes()[*node_1 as usize].name; @@ -491,8 +486,8 @@ impl Debug for OsdiDescriptor { } wn!("{} states", self.num_states); wn!("has bound_step {}", self.bound_step_offset != u32::MAX); - wn!("instance size {}", self.instance_size); - wn!("model size {}", self.model_size); + // instance_size and model_size are arch-specific (depend on struct alignment) + // so we omit them from snapshots to allow cross-platform testing Ok(()) } } diff --git a/openvaf/osdi/Cargo.toml b/openvaf/osdi/Cargo.toml index 8e59d3b8c..ad724a795 100644 --- a/openvaf/osdi/Cargo.toml +++ b/openvaf/osdi/Cargo.toml @@ -8,6 +8,13 @@ license = "GPL-3.0" [lib] doctest = false +[features] +# No default - user must specify --features llvm18/llvm19/llvm20/llvm21 +llvm18 = ["dep:llvm-sys-181", "mir_llvm/llvm18"] +llvm19 = ["dep:llvm-sys-191", "mir_llvm/llvm19"] +llvm20 = ["dep:llvm-sys-201", "mir_llvm/llvm20"] +llvm21 = ["dep:llvm-sys-211", "mir_llvm/llvm21"] + [dependencies] stdx = { version = "0.0.0", path = "../../lib/stdx" } @@ -20,15 +27,18 @@ hir = { version = "0.0.0", path = "../hir" } sim_back = { version = "0.0.0", path = "../sim_back" } mir = { version = "0.0.0", path = "../mir" } -mir_llvm = { version = "0.0.0", path = "../mir_llvm" } +mir_llvm = { version = "0.0.0", path = "../mir_llvm", default-features = false } syntax = { version = "0.0.0", path = "../syntax" } #llvm = { version = "0.0.0", path = "../llvm" } -llvm-sys = "181.1.1" +llvm-sys-181 = { package = "llvm-sys", version = "181.2.0", optional = true } +llvm-sys-191 = { package = "llvm-sys", version = "191.0.0", optional = true } +llvm-sys-201 = { package = "llvm-sys", version = "201.0.1", optional = true } +llvm-sys-211 = { package = "llvm-sys", version = "211.0.0", optional = true } target = { version = "0.0.0", path = "../target"} typed-index-collections = "3.1" -ahash = "0.8" +rustc-hash = "2.0" lasso = {version = "0.7", features = ["ahash"]} salsa = "0.17.0-pre.2" diff --git a/openvaf/osdi/build.rs b/openvaf/osdi/build.rs index 0c609a5e9..1e8f9f1d2 100644 --- a/openvaf/osdi/build.rs +++ b/openvaf/osdi/build.rs @@ -22,6 +22,41 @@ fn main() { let osdi_dir = stdx::project_root().join("openvaf").join("osdi"); let src_file = osdi_dir.join("stdlib.c"); + // Use clang from LLVM prefix environment variables (check newest first) + // Fall back to Homebrew LLVM on macOS, then system clang + let clang_path = tracked_env_var_os("LLVM_SYS_211_PREFIX") + .or_else(|| tracked_env_var_os("LLVM_SYS_201_PREFIX")) + .or_else(|| tracked_env_var_os("LLVM_SYS_191_PREFIX")) + .or_else(|| tracked_env_var_os("LLVM_SYS_181_PREFIX")) + .map(|prefix| Path::new(&prefix).join("bin/clang")) + .and_then(|path| path.exists().then_some(path)) + .or_else(|| { + // Try Homebrew LLVM paths on macOS + #[cfg(target_os = "macos")] + { + // Check HOMEBREW_PREFIX first, then common default locations + if let Some(prefix) = tracked_env_var_os("HOMEBREW_PREFIX") { + let p = Path::new(&prefix).join("opt/llvm/bin/clang"); + if p.exists() { + return Some(p); + } + } + let homebrew_paths = [ + "/opt/homebrew/opt/llvm/bin/clang", // Apple Silicon + "/usr/local/opt/llvm/bin/clang", // Intel Mac + ]; + for path in homebrew_paths { + let p = Path::new(path); + if p.exists() { + return Some(p.to_path_buf()); + } + } + } + None + }) + .map(|path| path.display().to_string()) + .unwrap_or_else(|| "clang".to_string()); + sh.change_dir(osdi_dir); for file in sh.read_dir("header").unwrap() { if file.extension().map_or(true, |ext| ext != "h") @@ -47,7 +82,7 @@ fn main() { } else { println!("cargo:rerun-if-changed={}", file.display()); - let mut cmd = cmd!(sh, "clang -emit-llvm -O3 -D{def_name} -DNO_STD -o {out_file} -c {src_file} -target {target_name}"); + let mut cmd = cmd!(sh, "{clang_path} -emit-llvm -O3 -D{def_name} -DNO_STD -o {out_file} -c {src_file} -target {target_name}"); if !target.options.is_like_windows { cmd = cmd.arg("-fPIC"); } diff --git a/openvaf/osdi/src/access.rs b/openvaf/osdi/src/access.rs index 444da5ce8..a3fd7bb41 100644 --- a/openvaf/osdi/src/access.rs +++ b/openvaf/osdi/src/access.rs @@ -167,6 +167,7 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { ); LLVMPositionBuilderAtEnd(llbuilder, bb); // construct case constant, add case with building block bb + // instance parameter IDs are 0..num_instance_params-1 let case = cx.const_unsigned_int(param_idx as u32); LLVMAddCase(switch_model, NonNull::from(case).as_ptr(), bb); @@ -213,6 +214,8 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { ); LLVMPositionBuilderAtEnd(llbuilder, bb); // construct case constant, add case with building block bb + // model parameter IDs are num_instance_params..num_instance_params+num_model_params-1 + // num_model_params == model_data.params.len() counts only model parameters let case = cx.const_unsigned_int((inst_data.params.len() + param_idx) as u32); LLVMAddCase(switch_model, NonNull::from(case).as_ptr(), bb); diff --git a/openvaf/osdi/src/compilation_unit.rs b/openvaf/osdi/src/compilation_unit.rs index ce4c5d14a..40f0b5d8b 100644 --- a/openvaf/osdi/src/compilation_unit.rs +++ b/openvaf/osdi/src/compilation_unit.rs @@ -8,8 +8,8 @@ use lasso::Rodeo; use llvm_sys::core::{ LLVMAddIncoming, LLVMAppendBasicBlockInContext, LLVMBuildAdd, LLVMBuildArrayMalloc, LLVMBuildBr, LLVMBuildCall2, LLVMBuildCondBr, LLVMBuildFMul, LLVMBuildFree, LLVMBuildICmp, - LLVMBuildInBoundsGEP2, LLVMBuildLoad2, LLVMBuildPhi, LLVMGetFirstFunction, LLVMGetNextFunction, - LLVMGetParam, LLVMIsDeclaration, LLVMPositionBuilderAtEnd, LLVMSetLinkage, + LLVMBuildInBoundsGEP2, LLVMBuildLoad2, LLVMBuildPhi, LLVMBuildZExt, LLVMGetFirstFunction, + LLVMGetNextFunction, LLVMGetParam, LLVMIsDeclaration, LLVMPositionBuilderAtEnd, LLVMSetLinkage, LLVMSetUnnamedAddress, }; use llvm_sys::{LLVMIntPredicate, LLVMLinkage, LLVMUnnamedAddr, LLVMValue}; @@ -449,10 +449,6 @@ fn print_callback<'ll>( FmtArgKind::Other => args.push(&*val), } } - args.extend( - (1..(2 + arg_tys.len())) - .map(|arg| &*LLVMGetParam(NonNull::from(fun).as_ptr(), arg as u32)), - ); let (fun_ty, fun) = cx.intrinsic("snprintf").unwrap(); // Convert Vec<&LLVMValue> to Vec<*mut LLVMValue> let mut raw_args: Vec<*mut LLVMValue> = @@ -504,6 +500,9 @@ fn print_callback<'ll>( LLVMPositionBuilderAtEnd(llbuilder, write_bb); let data_len = LLVMBuildAdd(llbuilder, len, NonNull::from(cx.const_int(1)).as_ptr(), UNNAMED); + // LLVM value data_len is i32, we need size_t because snprintf needs it. Zero extend to get size_t + let data_len = + LLVMBuildZExt(llbuilder, data_len, NonNull::from(cx.ty_size()).as_ptr(), UNNAMED); raw_args[0] = ptr; raw_args[1] = data_len; let len = LLVMBuildCall2( diff --git a/openvaf/osdi/src/inst_data.rs b/openvaf/osdi/src/inst_data.rs index 189aa857a..b8fd1db3e 100644 --- a/openvaf/osdi/src/inst_data.rs +++ b/openvaf/osdi/src/inst_data.rs @@ -1,7 +1,7 @@ use core::ffi::c_uint; use core::ptr::NonNull; +use std::hash::BuildHasherDefault; -use ahash::RandomState; use hir::{CompilationDB, ParamSysFun, Parameter, Variable}; use hir_lower::{HirInterner, LimitState, ParamKind, PlaceKind}; use indexmap::IndexMap; @@ -21,6 +21,7 @@ use llvm_sys::target::{LLVMOffsetOfElement, LLVMTargetDataRef}; use llvm_sys::LLVMIntPredicate; use mir::{strip_optbarrier, Const, Function, Param, ValueDef, F_ZERO}; use mir_llvm::{CodegenCx, MemLoc, UNNAMED}; +use rustc_hash::FxHasher; use sim_back::dae::{self, MatrixEntryId, SimUnknown}; use sim_back::init::CacheSlot; use stdx::packed_option::PackedOption; @@ -212,13 +213,13 @@ pub struct OsdiInstanceData<'ll> { pub collapsed: &'ll llvm_sys::LLVMType, // llvm types for dynamic instance data struct fields - pub params: IndexMap, + pub params: IndexMap>, pub eval_outputs: TiMap, pub cache_slots: TiVec, pub residual: TiVec, pub noise: Vec, - pub opvars: IndexMap, + pub opvars: IndexMap>, pub jacobian: TiVec, pub bound_step: Option, } @@ -244,21 +245,17 @@ impl<'ll> OsdiInstanceData<'ll> { let user_inst_params = module.info.params.iter().filter_map(|(param, info)| { info.is_instance.then(|| (OsdiInstanceParam::User(*param), lltype(¶m.ty(db), cx))) }); - let params: IndexMap<_, _, _> = - builtin_inst_params.chain(alias_inst_params).chain(user_inst_params).collect(); + let mut params = IndexMap::with_hasher(BuildHasherDefault::::default()); + params.extend(builtin_inst_params.chain(alias_inst_params).chain(user_inst_params)); let mut eval_outputs = TiMap::default(); - let opvars = module - .info - .op_vars - .keys() - .map(|var| { - let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked(); - let ty = lltype(&var.ty(db), cx); - let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty); - (*var, pos) - }) - .collect(); + let mut opvars = IndexMap::with_hasher(BuildHasherDefault::::default()); + opvars.extend(module.info.op_vars.keys().map(|var| { + let val = module.intern.outputs[&PlaceKind::Var(*var)].unwrap_unchecked(); + let ty = lltype(&var.ty(db), cx); + let pos = EvalOutput::new(module, val, &mut eval_outputs, true, ty); + (*var, pos) + })); let residual = module .dae_system .residual diff --git a/openvaf/osdi/src/lib.rs b/openvaf/osdi/src/lib.rs index 970d2ac6c..520877dec 100644 --- a/openvaf/osdi/src/lib.rs +++ b/openvaf/osdi/src/lib.rs @@ -1,8 +1,21 @@ +// Re-export the correct llvm-sys version based on feature flags +#[cfg(feature = "llvm18")] +extern crate llvm_sys_181 as llvm_sys; +#[cfg(feature = "llvm19")] +extern crate llvm_sys_191 as llvm_sys; +#[cfg(feature = "llvm20")] +extern crate llvm_sys_201 as llvm_sys; +#[cfg(feature = "llvm21")] +extern crate llvm_sys_211 as llvm_sys; + use std::collections::HashMap; use std::ffi::CString; +use std::hash::BuildHasherDefault; use std::ptr::NonNull; use std::sync::{Arc, Mutex}; +use rustc_hash::FxHasher; + use base_n::CASE_INSENSITIVE; use camino::{Utf8Path, Utf8PathBuf}; use hir::{CompilationDB, ParamSysFun, Type}; @@ -115,8 +128,9 @@ pub fn compile<'a>( let main_file = dst.with_extension("o"); - let unoptirs = Arc::new(Mutex::new(HashMap::new())); - let irs = Arc::new(Mutex::new(HashMap::new())); + let unoptirs = + Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::::default()))); + let irs = Arc::new(Mutex::new(HashMap::with_hasher(BuildHasherDefault::::default()))); // Build natures, disciplines, and attributes vectors, intern strings in Rodeo let (natures_vec, disciplines_vec, attributes_vec) = nda_arrays(&*db, &mut literals); diff --git a/openvaf/osdi/src/model_data.rs b/openvaf/osdi/src/model_data.rs index 0d2bc2f09..272106c8c 100644 --- a/openvaf/osdi/src/model_data.rs +++ b/openvaf/osdi/src/model_data.rs @@ -1,11 +1,12 @@ use core::ptr::NonNull; +use std::hash::BuildHasherDefault; -use ahash::RandomState; use hir::{CompilationDB, Parameter}; use indexmap::IndexMap; use llvm_sys::core::{LLVMBuildLoad2, LLVMBuildStore, LLVMBuildStructGEP2}; use llvm_sys::LLVMValue as Value; use mir_llvm::{CodegenCx, MemLoc, UNNAMED}; +use rustc_hash::FxHasher; use crate::compilation_unit::OsdiModule; use crate::inst_data::{OsdiInstanceData, OsdiInstanceParam}; @@ -15,7 +16,7 @@ const NUM_CONST_FIELDS: u32 = 1; pub struct OsdiModelData<'ll> { pub param_given: &'ll llvm_sys::LLVMType, - pub params: IndexMap, + pub params: IndexMap>, pub ty: &'ll llvm_sys::LLVMType, } @@ -27,18 +28,14 @@ impl<'ll> OsdiModelData<'ll> { inst_data: &OsdiInstanceData<'ll>, ) -> Self { let inst_params = &inst_data.params; - let params: IndexMap<_, _, _> = cgunit - .info - .params - .keys() - .filter_map(|param| { - if inst_params.contains_key(&OsdiInstanceParam::User(*param)) { - None - } else { - Some((*param, lltype(¶m.ty(db), cx))) - } - }) - .collect(); + let mut params = IndexMap::with_hasher(BuildHasherDefault::::default()); + params.extend(cgunit.info.params.keys().filter_map(|param| { + if inst_params.contains_key(&OsdiInstanceParam::User(*param)) { + None + } else { + Some((*param, lltype(¶m.ty(db), cx))) + } + })); let param_given = bitfield::arr_ty((inst_params.len() + params.len()) as u32, cx); @@ -165,6 +162,22 @@ impl<'ll> OsdiModelData<'ll> { ); } + pub unsafe fn store_nth_inst_param( + &self, + inst_data: &OsdiInstanceData<'ll>, + param: u32, + ptr: &'ll Value, + val: &'ll llvm_sys::LLVMValue, + llbuilder: &llvm_sys::LLVMBuilder, + ) { + let (ptr, _) = self.nth_inst_param_ptr(inst_data, param, ptr, llbuilder); + LLVMBuildStore( + NonNull::from(llbuilder).as_ptr(), + NonNull::from(val).as_ptr(), + NonNull::from(ptr).as_ptr(), + ); + } + // pub unsafe fn read_nth_param( // &self, // param: u32, diff --git a/openvaf/osdi/src/setup.rs b/openvaf/osdi/src/setup.rs index fee4a5732..fd2ac3887 100644 --- a/openvaf/osdi/src/setup.rs +++ b/openvaf/osdi/src/setup.rs @@ -3,9 +3,12 @@ use core::ptr::NonNull; use hir_lower::{CallBackKind, ParamInfoKind, ParamKind, PlaceKind}; use llvm_sys::core::{ LLVMAppendBasicBlockInContext, LLVMBuildBr, LLVMBuildCondBr, LLVMBuildRetVoid, - LLVMCreateBuilderInContext, LLVMDisposeBuilder, LLVMGetParam, LLVMPositionBuilderAtEnd, + LLVMCreateBuilderInContext, LLVMDisposeBuilder, LLVMGetInsertBlock, LLVMGetLastInstruction, + LLVMGetParam, LLVMPositionBuilder, LLVMPositionBuilderAtEnd, }; +use llvm_sys::prelude::LLVMBasicBlockRef; use llvm_sys::LLVMIntPredicate::LLVMIntSLT; +use llvm_sys::LLVMValue; use mir::ControlFlowGraph; use mir_llvm::{ Builder, BuilderVal, BuiltCallbackFun, CallbackFun, CodegenCx, InlineCallbackBuilder, UNNAMED, @@ -15,6 +18,8 @@ use sim_back::SimUnknownKind; use crate::compilation_unit::{general_callbacks, OsdiCompilationUnit}; use crate::inst_data::OsdiInstanceParam; +use std::collections::HashMap; + struct VoidAbortCallback; impl<'ll> InlineCallbackBuilder<'ll> for VoidAbortCallback { @@ -162,6 +167,9 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { builder.params[dst] = BuilderVal::Eager(is_given); } + let mut builtin_blocks: HashMap = HashMap::new(); + let mut builtin_values: HashMap = HashMap::new(); + for (i, param) in inst_data.params.keys().enumerate() { let i = i as u32; @@ -173,10 +181,16 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { match *param { OsdiInstanceParam::Builtin(builtin) => { + let default_val = builtin.default_value(); + let default_val = cx.const_real(default_val); + let val = unsafe { builder.select(is_given, val, default_val) }; + unsafe { + let bb = LLVMGetInsertBlock(builder.llbuilder); + builtin_blocks.insert(*param, bb); + } + builtin_values.insert(*param, val); + // Never true! But does not matter because we never use these LLVM values in built code. if let Some(dst) = intern.params.index(&ParamKind::ParamSysFun(builtin)) { - let default_val = builtin.default_value(); - let default_val = cx.const_real(default_val); - let val = unsafe { builder.select(is_given, val, default_val) }; builder.params[dst] = BuilderVal::Eager(val); } } @@ -253,7 +267,7 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { }) .unwrap(); - // store parameters + // store model parameters to reflect defaulted values for (i, param) in model_data.params.keys().enumerate() { let val = intern.outputs[&PlaceKind::Param(*param)].unwrap_unchecked(); let inst = func.dfg.value_def(val).unwrap_inst(); @@ -265,6 +279,49 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { } } + // store instance parameters to reflect defaulted values + for (i, param) in inst_data.params.keys().enumerate() { + match param { + OsdiInstanceParam::Builtin(_) => { + if let Some(bb) = builtin_blocks.get(param) { + let val = builtin_values.get(param).unwrap(); + unsafe { + let bb_ptr = NonNull::from(&**bb).as_ptr(); + let inst = LLVMGetLastInstruction(bb_ptr); + LLVMPositionBuilder( + builder.llbuilder as *const _ as *mut _, + bb_ptr, + inst, + ); + model_data.store_nth_inst_param( + inst_data, + i as u32, + &*model, + val, + builder.llbuilder, + ); + } + } + } + OsdiInstanceParam::User(param) => { + let val = intern.outputs[&PlaceKind::Param(*param)].unwrap_unchecked(); + let inst = func.dfg.value_def(val).unwrap_inst(); + let bb = func.layout.inst_block(inst).unwrap(); + builder.select_bb_before_terminator(bb); + unsafe { + let val = builder.values[val].get(&builder); + model_data.store_nth_inst_param( + inst_data, + i as u32, + &*model, + val, + builder.llbuilder, + ); + } + } + } + } + builder.select_bb(exit_bb); unsafe { builder.ret_void() } @@ -365,6 +422,10 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { OsdiInstanceParam::User(param) => { let dst = intern.params.unwrap_index(&ParamKind::Param(param)); builder.params[dst] = BuilderVal::Eager(val); + // Store in instance structure to reflect defaulted value + unsafe { + inst_data.store_nth_param(i, instance, val, builder.llbuilder); + } let dst = intern.params.unwrap_index(&ParamKind::ParamGiven { param }); builder.params[dst] = BuilderVal::Eager(is_given); } @@ -482,6 +543,9 @@ impl<'ll> OsdiCompilationUnit<'_, '_, 'll> { } unsafe { + // This fills builder.values with builder.params based on + // param keys associated with a MIR values. + // Also builds constants from MIR builder.build_consts(); builder.build_func(); } diff --git a/openvaf/osdi/tests/data_tests.rs b/openvaf/osdi/tests/data_tests.rs index fcf8ed744..513e5c3e4 100644 --- a/openvaf/osdi/tests/data_tests.rs +++ b/openvaf/osdi/tests/data_tests.rs @@ -3,9 +3,8 @@ use std::path::Path; use camino::Utf8Path; use hir::diagnostics::ConsoleSink; use hir::CompilationDB; -use llvm_sys::target_machine::LLVMCodeGenOptLevel; use mini_harness::{harness, Result}; -use mir_llvm::LLVMBackend; +use mir_llvm::{LLVMBackend, LLVMCodeGenOptLevel}; use paths::AbsPathBuf; use sim_back::collect_modules; use stdx::{ignore_slow_tests, project_root}; diff --git a/openvaf/sim_back/Cargo.toml b/openvaf/sim_back/Cargo.toml index 31fc5282f..ec2fda79d 100644 --- a/openvaf/sim_back/Cargo.toml +++ b/openvaf/sim_back/Cargo.toml @@ -24,6 +24,7 @@ mir_opt = { version = "0.0.0", path = "../mir_opt" } typed-index-collections = "3.1" ahash = "0.8" +rustc-hash = "2.0" lasso = {version = "0.7", features = ["ahash"]} indexmap = "2.0" diff --git a/openvaf/sim_back/src/context.rs b/openvaf/sim_back/src/context.rs index 17d456873..eb518e019 100644 --- a/openvaf/sim_back/src/context.rs +++ b/openvaf/sim_back/src/context.rs @@ -2,7 +2,7 @@ use bitset::{BitSet, SparseBitMatrix}; use hir::CompilationDB; use hir_lower::{HirInterner, MirBuilder, PlaceKind}; use lasso::Rodeo; -use mir::{InstructionData, Block, ControlFlowGraph, DominatorTree, Function, Inst, Value}; +use mir::{Block, ControlFlowGraph, DominatorTree, Function, Inst, InstructionData, Value}; use mir_opt::{ aggressive_dead_code_elimination, dead_code_elimination, inst_combine, propagate_direct_taint, propagate_taint, simplify_cfg, simplify_cfg_no_phi_merge, @@ -40,7 +40,7 @@ impl<'a> Context<'a> { PlaceKind::Contribute { .. } | PlaceKind::ImplicitResidual { .. } | PlaceKind::CollapseImplicitEquation(_) - | PlaceKind::IsVoltageSrc(_) + | PlaceKind::IsVoltageSrc(_) | PlaceKind::BoundStep => true, PlaceKind::Var(var) => module.op_vars.contains_key(&var), _ => false, @@ -148,7 +148,7 @@ impl<'a> Context<'a> { self.op_dependent_vals.push(val) } } - + // Propagate taint propagate_direct_taint( &self.func, @@ -167,9 +167,9 @@ impl<'a> Context<'a> { for (cb, uses) in self.intern.callback_uses.iter_mut_enumerated() { // Ff callback is op dependent if self.intern.callbacks[cb].op_dependent() { - // Remove uses that appear in instructions that are not inserted into the layout. - // Add to op dependent instructions. - // Add the results of these instructions to op dependent values. + // Remove uses that appear in instructions that are not inserted into the layout. + // Add to op dependent instructions. + // Add the results of these instructions to op dependent values. uses.retain(|&inst| { if self.func.layout.inst_block(inst).is_none() { return false; @@ -183,13 +183,13 @@ impl<'a> Context<'a> { } } // Go through parameters, if the corresponding value is not dead and is op dependent - // (i.e. current, voltage, abstime, ...) add it to op dependent values. + // (i.e. current, voltage, abstime, ...) add it to op dependent values. for (param, &val) in self.intern.params.iter() { if !dfg.value_dead(val) && param.op_dependent() { self.op_dependent_vals.push(val) } } - + // Propagate taint propagate_taint( &self.func, diff --git a/openvaf/sim_back/src/dae.rs b/openvaf/sim_back/src/dae.rs index 57b4c7be0..2e22fd502 100644 --- a/openvaf/sim_back/src/dae.rs +++ b/openvaf/sim_back/src/dae.rs @@ -1,5 +1,8 @@ +use std::hash::BuildHasherDefault; + use indexmap::IndexSet; use mir::{strip_optbarrier, Value, F_ZERO}; +use rustc_hash::FxHasher; use stdx::{impl_debug_display, impl_idx_from}; use typed_index_collections::TiVec; use typed_indexmap::TiSet; @@ -40,7 +43,7 @@ pub struct DaeSystem { pub jacobian: TiVec, /// list of parameter which are known to be small signal values (always zero during /// large signal simulation). - pub small_signal_parameters: IndexSet, + pub small_signal_parameters: IndexSet>, /// noise pub noise_sources: Vec, /// model inputs (node pairs) diff --git a/openvaf/sim_back/src/dae/builder.rs b/openvaf/sim_back/src/dae/builder.rs index 2fa47016b..3c6b6d4b6 100644 --- a/openvaf/sim_back/src/dae/builder.rs +++ b/openvaf/sim_back/src/dae/builder.rs @@ -1,7 +1,3 @@ -use std::mem::replace; -use std::vec; - -use ahash::AHashMap; use bitset::BitSet; use hir::{BranchWrite, CompilationDB, Node, ParamSysFun}; use hir_lower::{CurrentKind, HirInterner, ImplicitEquation, ParamKind}; @@ -13,6 +9,11 @@ use mir::{ Value, FALSE, F_ONE, F_ZERO, TRUE, }; use mir_autodiff::auto_diff; +use rustc_hash::FxHasher; +use std::collections::HashMap; +use std::hash::BuildHasherDefault; +use std::mem::replace; +use std::vec; use typed_index_collections::TiVec; use crate::context::Context; @@ -122,7 +123,7 @@ impl<'a> Builder<'a> { pub(super) fn with_small_signal_network( mut self, - small_signal_parameters: IndexSet, + small_signal_parameters: IndexSet>, ) -> Self { self.system.small_signal_parameters = small_signal_parameters; self @@ -219,7 +220,7 @@ impl<'a> Builder<'a> { fn build_lim_rhs( &mut self, derivative_info: &KnownDerivatives, - derivatives: AHashMap<(Value, Unknown), Value>, + derivatives: HashMap<(Value, Unknown), Value, BuildHasherDefault>, ) { for residual in &mut self.system.residual { for (state, (unchanged, lim_vals)) in self.intern.lim_state.iter_enumerated() { @@ -272,7 +273,7 @@ impl<'a> Builder<'a> { &mut self, sim_unknown_reads: &[(ParamKind, Value)], derivative_info: &KnownDerivatives, - derivatives: &AHashMap<(Value, Unknown), Value>, + derivatives: &HashMap<(Value, Unknown), Value, BuildHasherDefault>, ) { self.system.jacobian = TiVec::with_capacity(self.system.unknowns.len() * self.system.unknowns.len()); diff --git a/openvaf/sim_back/src/init.rs b/openvaf/sim_back/src/init.rs index aaab86318..9c3e4254f 100644 --- a/openvaf/sim_back/src/init.rs +++ b/openvaf/sim_back/src/init.rs @@ -1,4 +1,6 @@ -use ahash::{AHashMap, AHashSet, RandomState}; +use std::hash::BuildHasherDefault; + +use ahash::{AHashMap, AHashSet}; use bitset::{BitSet, SparseBitMatrix}; use hir::{CompilationDB, Type}; use hir_lower::{HirInterner, ParamKind, PlaceKind}; @@ -10,6 +12,7 @@ use mir::{ InstructionData, Opcode, Value, FALSE, }; use mir_opt::{aggressive_dead_code_elimination, simplify_cfg, simplify_cfg_init, ClassId, GVN}; +use rustc_hash::FxHasher; use stdx::packed_option::PackedOption; use stdx::{impl_debug_display, impl_idx_from}; use typed_indexmap::TiMap; @@ -31,7 +34,7 @@ impl_debug_display! {match CacheSlot{CacheSlot(id) => "cslot{id}";}} pub struct Initialization { pub func: Function, pub intern: HirInterner, - pub cached_vals: IndexMap, + pub cached_vals: IndexMap>, pub cache_slots: TiMap, u32), hir::Type>, } @@ -62,7 +65,7 @@ impl Initialization { struct Builder<'a> { init: Initialization, - init_cache: IndexMap, + init_cache: IndexMap>, // inputs func: &'a mut Function, cfg: &'a mut ControlFlowGraph, @@ -81,11 +84,17 @@ impl<'a> Builder<'a> { Builder { init: Initialization { func: Function::with_name(format!("{}_init", &ctx.func.name)), - cached_vals: IndexMap::with_capacity_and_hasher(128, RandomState::new()), + cached_vals: IndexMap::with_capacity_and_hasher( + 128, + BuildHasherDefault::::default(), + ), cache_slots: TiMap::default(), intern: HirInterner::default(), }, - init_cache: IndexMap::with_capacity_and_hasher(256, RandomState::default()), + init_cache: IndexMap::with_capacity_and_hasher( + 256, + BuildHasherDefault::::default(), + ), func: &mut ctx.func, cfg: &mut ctx.cfg, dom_tree: &mut ctx.dom_tree, diff --git a/openvaf/sim_back/src/lib.rs b/openvaf/sim_back/src/lib.rs index dec6c022d..c1f03a8c0 100644 --- a/openvaf/sim_back/src/lib.rs +++ b/openvaf/sim_back/src/lib.rs @@ -189,7 +189,6 @@ impl<'a> CompiledModule<'a> { cx.compute_cfg(); let gvn = cx.optimize(OptimiziationStage::PostDerivative); dae_system.sparsify(&mut cx); - debug_assert!(cx.func.validate()); // Instance setup MIR - a copy of module MIR where only those instructions diff --git a/openvaf/sim_back/src/module_info.rs b/openvaf/sim_back/src/module_info.rs index 20df49c41..2e33538b7 100644 --- a/openvaf/sim_back/src/module_info.rs +++ b/openvaf/sim_back/src/module_info.rs @@ -1,3 +1,5 @@ +use std::hash::BuildHasherDefault; + use ahash::AHashSet; use hir::diagnostics::{BaseDB, ConsoleSink, Diagnostic, FileId, Label, LabelStyle, Report}; use hir::{ @@ -5,6 +7,7 @@ use hir::{ ResolvedAliasParameter, ScopeDef, Variable, }; use indexmap::IndexMap; +use rustc_hash::FxHasher; use smol_str::SmolStr; use syntax::ast::{self, Expr}; use syntax::sourcemap::FileSpan; @@ -42,9 +45,9 @@ pub fn collect_modules( pub struct ModuleInfo { pub module: Module, - pub params: IndexMap, - pub sys_fun_alias: IndexMap, ahash::RandomState>, - pub op_vars: IndexMap, + pub params: IndexMap>, + pub sys_fun_alias: IndexMap, BuildHasherDefault>, + pub op_vars: IndexMap>, } impl ModuleInfo { @@ -55,10 +58,12 @@ impl ModuleInfo { sink: &mut ConsoleSink, all_vars_opvars: bool, ) -> ModuleInfo { - let mut params: IndexMap = IndexMap::default(); - let mut sys_fun_alias: IndexMap, ahash::RandomState> = + let mut params: IndexMap> = + IndexMap::default(); + let mut sys_fun_alias: IndexMap, BuildHasherDefault> = + IndexMap::default(); + let mut op_vars: IndexMap> = IndexMap::default(); - let mut op_vars = IndexMap::default(); let ast = cu.ast(db); diff --git a/openvaf/sim_back/src/topology.rs b/openvaf/sim_back/src/topology.rs index 2a31741c2..0133e1993 100644 --- a/openvaf/sim_back/src/topology.rs +++ b/openvaf/sim_back/src/topology.rs @@ -17,6 +17,8 @@ //! generation of unnecessary derivatives. //! +use std::hash::BuildHasherDefault; + use ahash::AHashMap; use bitset::{BitSet, SparseBitMatrix}; use hir_lower::{CallBackKind, HirInterner, ImplicitEquation, ParamKind, PlaceKind}; @@ -25,6 +27,7 @@ use lasso::Spur; use mir::{strip_optbarrier, Function, Inst, Value, F_ZERO, TRUE}; use mir_build::SSAVariableBuilder; use mir_opt::simplify_cfg_no_phi_merge; +use rustc_hash::FxHasher; use stdx::{impl_debug_display, impl_idx_from}; use typed_index_collections::TiVec; use typed_indexmap::TiMap; @@ -150,7 +153,7 @@ impl Noise { pub(crate) struct Topology { pub(crate) branches: TiMap, pub(crate) implicit_equations: TiVec, - pub(crate) small_signal_vals: IndexSet, + pub(crate) small_signal_vals: IndexSet>, contributes: AHashMap, } @@ -284,7 +287,7 @@ impl Topology { implicit_equations, small_signal_vals: IndexSet::with_capacity_and_hasher( 128, - ahash::RandomState::default(), + BuildHasherDefault::::default(), ), }; let num_insts = ctx.func.dfg.num_insts(); diff --git a/openvaf/sim_back/src/topology/small_signal_network.rs b/openvaf/sim_back/src/topology/small_signal_network.rs index 45da1a708..d883f6183 100644 --- a/openvaf/sim_back/src/topology/small_signal_network.rs +++ b/openvaf/sim_back/src/topology/small_signal_network.rs @@ -1,9 +1,11 @@ +use std::hash::BuildHasherDefault; use std::iter::once; use std::mem::take; use hir::Node; use indexmap::IndexMap; use mir::{Const, InstructionData, Opcode, Value, ValueDef, FALSE, F_ZERO}; +use rustc_hash::FxHasher; use crate::topology::Builder; use crate::util::{add, update_optbarrier}; @@ -56,7 +58,7 @@ enum CandidateKind { } impl Builder<'_> { - /// explores all `candidates` to extract the noise network + /// Explores all `candidates` to extract the noise network fn solve(&mut self, candidates: &mut Vec) { loop { let mut changed = false; @@ -82,7 +84,7 @@ impl Builder<'_> { } changed = true; } else if let Some(node) = candidate.as_node() { - self.topology.small_signal_vals.remove(&node); + self.topology.small_signal_vals.swap_remove(&node); } set == FlatSet::Bottom }); @@ -305,7 +307,8 @@ impl Builder<'_> { } fn collect_candidates(&mut self) -> Vec { - let mut nodes = IndexMap::with_capacity_and_hasher(32, ahash::RandomState::new()); + let mut nodes = + IndexMap::with_capacity_and_hasher(32, BuildHasherDefault::::default()); let mut candidates = Vec::new(); for (_, (&branch, contributes)) in self.topology.branches() { let (hi, lo) = branch.nodes(self.db); diff --git a/openvaf/sim_back/src/topology/test.rs b/openvaf/sim_back/src/topology/test.rs index a608fbc29..4b63010ea 100644 --- a/openvaf/sim_back/src/topology/test.rs +++ b/openvaf/sim_back/src/topology/test.rs @@ -221,3 +221,39 @@ fn psp103() { assert(src); } + +/// Regression test for issue #30: Small signal analysis with constant offset +/// +/// This test verifies that when a contribution has a constant offset (like V(pn1) - 1), +/// the node is NOT incorrectly marked as a small signal value. The buggy algorithm +/// speculatively added all candidate nodes to small_signal_vals before analysis, +/// which caused V(pn2) to incorrectly see V(pn1) as a small signal value during +/// its evaluation, leading to V(pn2) being incorrectly marked as small signal. +/// +/// The correct behavior is: +/// - V(pn1) - 1 has a constant term, so pn1 is NOT small signal +/// - V(pn2) - V(pn1) depends on pn1 which is NOT small signal, so pn2 is also NOT small signal +/// - Therefore small_signal_vals should be empty +#[test] +fn constant_offset_not_small_signal() { + let src = indoc! {r#" + `include "disciplines.vams" + module constant_offset_not_small_signal(inout pn1, inout pn2); + electrical pn1, pn2; + analog begin + I(pn1) <+ V(pn1) - 1; + I(pn2) <+ V(pn2) - V(pn1); + end + endmodule + "#}; + + let (_, topology, _) = compile(src); + // The bug would incorrectly add V(pn2) to small_signal_vals because during + // evaluation it would see V(pn1) as "speculatively" in the set. + // The correct behavior is that neither node should be in small_signal_vals. + assert!( + topology.small_signal_vals.is_empty(), + "small_signal_vals should be empty but contains {:?}", + topology.small_signal_vals + ); +} diff --git a/openvaf/target/src/spec/aarch64_apple_darwin.rs b/openvaf/target/src/spec/aarch64_apple_darwin.rs index 6aef6a9c5..d598f24eb 100644 --- a/openvaf/target/src/spec/aarch64_apple_darwin.rs +++ b/openvaf/target/src/spec/aarch64_apple_darwin.rs @@ -9,11 +9,21 @@ pub fn target() -> Target { vec![ "-arch".to_string(), "arm64".to_string(), + "-platform_version".to_string(), + "macos".to_string(), + "11.0".to_string(), + "11.0".to_string(), "-undefined".to_string(), "dynamic_lookup".to_string(), ], ); + // Link against libSystem which provides dyld_stub_binder + base.post_link_args.insert( + LinkerFlavor::Ld64, + vec!["-lSystem".to_string()], + ); + Target { llvm_target: "arm64-apple-macosx11.0.0".to_owned(), pointer_width: 64, diff --git a/openvaf/target/src/spec/x86_64_apple_darwin.rs b/openvaf/target/src/spec/x86_64_apple_darwin.rs index 7a852654c..4525691b2 100644 --- a/openvaf/target/src/spec/x86_64_apple_darwin.rs +++ b/openvaf/target/src/spec/x86_64_apple_darwin.rs @@ -10,11 +10,21 @@ pub fn target() -> Target { vec![ "-arch".to_string(), "x86_64".to_string(), + "-platform_version".to_string(), + "macos".to_string(), + "10.15".to_string(), + "10.15".to_string(), "-undefined".to_string(), "dynamic_lookup".to_string(), ], ); + // Link against libSystem which provides dyld_stub_binder + base.post_link_args.insert( + LinkerFlavor::Ld64, + vec!["-lSystem".to_string()], + ); + Target { llvm_target: "x86_64-apple-macosx10.15.0".to_owned(), arch: "x86_64".to_owned(), diff --git a/openvaf/test_data/osdi/amplifier.snap b/openvaf/test_data/osdi/amplifier.snap index d6eeb92d5..77b7000ef 100644 --- a/openvaf/test_data/osdi/amplifier.snap +++ b/openvaf/test_data/osdi/amplifier.snap @@ -8,34 +8,26 @@ param "G" units = "", desc = "Voltage amplification factor", flags = ParameterFlags(0x0) 4 terminals -node "Inp" units = "V", runits = "" -residual 224 4294967295 4294967295 4294967295 -node "Inm" units = "V", runits = "" -residual 232 4294967295 4294967295 4294967295 -node "Outp" units = "V", runits = "" -residual 240 4294967295 4294967295 4294967295 -node "Outm" units = "V", runits = "" -residual 248 4294967295 4294967295 4294967295 -node(flow) "flow(Outp)" units = "A", runits = "" -residual 256 4294967295 4294967295 4294967295 -node(flow) "flow(Outm)" units = "A", runits = "" -residual 264 4294967295 4294967295 4294967295 -jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, flow(Outp)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, flow(Outm)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(Outp), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(Outp), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(Outp), Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(Outm), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(Outm), Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "Inp" units = "V", runits = "A" +node "Inm" units = "V", runits = "A" +node "Outp" units = "V", runits = "A" +node "Outm" units = "V", runits = "A" +node(flow) "flow(Outp)" units = "A", runits = "V" +node(flow) "flow(Outm)" units = "A", runits = "V" +jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, flow(Outp)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, flow(Outm)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(Outp), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(Outp), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(Outp), Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(Outm), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(Outm), Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 272 -model size 40 diff --git a/openvaf/test_data/osdi/asmhemt.snap b/openvaf/test_data/osdi/asmhemt.snap index 6c19688c0..be41cb64c 100644 --- a/openvaf/test_data/osdi/asmhemt.snap +++ b/openvaf/test_data/osdi/asmhemt.snap @@ -400,180 +400,164 @@ param "gdsmin" units = "S", desc = " Convergence Parameter", flags = ParameterFlags(0x0) 5 terminals -node "d" units = "V", runits = "" -residual 2792 2800 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 2808 2816 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 2824 2832 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 4294967295 2840 4294967295 4294967295 -node "dt" units = "K", runits = "" -residual 2848 2856 4294967295 4294967295 -node "trap1" units = "V", runits = "" -residual 2864 2872 4294967295 4294967295 -node "trap2" units = "V", runits = "" -residual 2880 2888 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 2896 2904 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 2912 2920 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 2928 2936 4294967295 4294967295 -node "fp1" units = "V", runits = "" -residual 2944 2952 4294967295 4294967295 -node "fp2" units = "V", runits = "" -residual 2960 2968 4294967295 4294967295 -node "fp3" units = "V", runits = "" -residual 2976 2984 4294967295 4294967295 -node "fp4" units = "V", runits = "" -residual 2992 3000 4294967295 4294967295 -node(flow) "flow(di,si)" units = "A", runits = "" -residual 3008 3016 4294967295 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "dt" units = "K", runits = "W" +node "trap1" units = "V", runits = "A" +node "trap2" units = "V", runits = "A" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "fp1" units = "V", runits = "A" +node "fp2" units = "V", runits = "A" +node "fp3" units = "V", runits = "A" +node "fp4" units = "V", runits = "A" +node(flow) "flow(di,si)" units = "A", runits = "A" node "implicit_equation_0" units = "", runits = "" -residual 3024 3032 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144 -jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1152 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1160 -jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1168 -jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176 -jacobian (d, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1184 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192 -jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1200 -jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1208 -jacobian (g, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1216 -jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1224 -jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1232 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1248 -jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256 -jacobian (s, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264 -jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1288 -jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1296 -jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1304 -jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1312 -jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1320 -jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1328 -jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1336 -jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1344 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1352 -jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1360 -jacobian (b, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1368 -jacobian (b, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1376 -jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1384 -jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1392 -jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1400 -jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1408 -jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1416 -jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1424 -jacobian (b, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1432 -jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1440 -jacobian (dt, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap1, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1448 -jacobian (trap1, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap2, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap2, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (trap2, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1456 -jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1464 -jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1472 -jacobian (di, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1480 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1488 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1496 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1504 -jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1512 -jacobian (di, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1520 -jacobian (si, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528 -jacobian (si, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1544 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1552 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560 -jacobian (si, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1568 -jacobian (gi, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1576 -jacobian (gi, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584 -jacobian (gi, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1608 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1616 -jacobian (gi, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1624 -jacobian (gi, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1632 -jacobian (gi, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640 -jacobian (gi, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648 -jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1656 -jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1664 -jacobian (fp1, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1672 -jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1680 -jacobian (fp1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1688 -jacobian (fp1, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1696 -jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1704 -jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1712 -jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1720 -jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1728 -jacobian (fp2, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1736 -jacobian (fp2, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1744 -jacobian (fp2, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1752 -jacobian (fp2, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1760 -jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1768 -jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1776 -jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1784 -jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1792 -jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1800 -jacobian (fp3, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1808 -jacobian (fp3, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1816 -jacobian (fp3, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1824 -jacobian (fp3, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1832 -jacobian (fp3, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1840 -jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1848 -jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1856 -jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1864 -jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1872 -jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1880 -jacobian (fp4, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fp4, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1888 -jacobian (fp4, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1896 -jacobian (fp4, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1904 -jacobian (fp4, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1912 -jacobian (fp4, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1920 -jacobian (fp4, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1928 -jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1936 -jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1944 -jacobian (flow(di,si), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(di,si), trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(di,si), trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(di,si), di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1952 -jacobian (flow(di,si), si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1960 -jacobian (flow(di,si), gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1968 -jacobian (flow(di,si), flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_0, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1976 -jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dt, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap1, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (trap1, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap2, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap2, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (trap2, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp1, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp2, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp2, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp2, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, trap2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp3, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp3, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp3, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fp4, trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp4, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), trap1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), trap2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(di,si), flow(di,si)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_0, trap1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (implicit_equation_0, gnd) collapsible (dt, gnd) collapsible (trap1, gnd) @@ -593,5 +577,3 @@ noise "thermal" (d, fp4) noise "thermal" (si, s) 0 states has bound_step false -instance size 4512 -model size 1608 diff --git a/openvaf/test_data/osdi/bsim3.snap b/openvaf/test_data/osdi/bsim3.snap index ffd3b83eb..38eaa496a 100644 --- a/openvaf/test_data/osdi/bsim3.snap +++ b/openvaf/test_data/osdi/bsim3.snap @@ -1450,40 +1450,34 @@ param "delvto" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 1904 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 1912 1920 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 1928 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 1936 1944 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 1952 1960 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 1968 1976 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 184 -jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 192 -jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 200 -jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 208 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 216 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 224 -jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 232 -jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 240 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 248 -jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 256 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272 -jacobian (si, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 280 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 288 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 296 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 304 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (s, si) collapsible (d, di) noise "Rs" (s, si) @@ -1492,5 +1486,3 @@ noise "flicker" (di, si) noise "ids" (di, si) 0 states has bound_step false -instance size 2304 -model size 5824 diff --git a/openvaf/test_data/osdi/bsim4.snap b/openvaf/test_data/osdi/bsim4.snap index 953d9b1cd..26f7049e4 100644 --- a/openvaf/test_data/osdi/bsim4.snap +++ b/openvaf/test_data/osdi/bsim4.snap @@ -1796,111 +1796,95 @@ param "pdvtp5" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 3424 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 3432 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 3440 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 3448 4294967295 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 3456 3464 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 3472 3480 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 3488 3496 4294967295 4294967295 -node "gm" units = "V", runits = "" -residual 3504 4294967295 4294967295 4294967295 -node "bi" units = "V", runits = "" -residual 3512 3520 4294967295 4294967295 -node "sbulk" units = "V", runits = "" -residual 3528 3536 4294967295 4294967295 -node "dbulk" units = "V", runits = "" -residual 3544 3552 4294967295 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "gm" units = "V", runits = "A" +node "bi" units = "V", runits = "A" +node "sbulk" units = "V", runits = "A" +node "dbulk" units = "V", runits = "A" node(flow) "flow(sbulk,bi)" units = "A", runits = "" -residual 3560 4294967295 4294967295 4294967295 node(flow) "flow(sbulk,b)" units = "A", runits = "" -residual 3568 4294967295 4294967295 4294967295 node(flow) "flow(b,bi)" units = "A", runits = "" -residual 3576 4294967295 4294967295 4294967295 node(flow) "flow(b,dbulk)" units = "A", runits = "" -residual 3584 4294967295 4294967295 4294967295 node(flow) "flow(bi,dbulk)" units = "A", runits = "" -residual 3592 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 616 -jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 664 -jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672 -jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704 -jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712 -jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720 -jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728 -jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736 -jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744 -jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752 -jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (bi, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768 -jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784 -jacobian (sbulk, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792 -jacobian (dbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800 -jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808 -jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816 -jacobian (dbulk, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,bi), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,bi), flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,b), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,b), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(sbulk,b), flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,bi), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,bi), flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,dbulk), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(b,dbulk), flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(bi,dbulk), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(bi,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(bi,dbulk), flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,bi), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,bi), flow(sbulk,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,b), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,b), sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(sbulk,b), flow(sbulk,b)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,bi), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,bi), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,bi), flow(b,bi)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,dbulk), b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(b,dbulk), flow(b,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(bi,dbulk), bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(bi,dbulk), dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(bi,dbulk), flow(bi,dbulk)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) collapsible (s, si) collapsible (d, di) collapsible (g, gm) @@ -1929,5 +1913,3 @@ noise "Rbulk" (flow(bi,dbulk), gnd) noise "Rg" (gi, g) 0 states has bound_step false -instance size 4256 -model size 7208 diff --git a/openvaf/test_data/osdi/bsim6.snap b/openvaf/test_data/osdi/bsim6.snap index 7c529881f..7a012a353 100644 --- a/openvaf/test_data/osdi/bsim6.snap +++ b/openvaf/test_data/osdi/bsim6.snap @@ -1786,115 +1786,101 @@ param "DVT2EDGE" units = "", desc = "Body-bias coefficient for SCE effect for Edge FET", flags = ParameterFlags(0x0) 5 terminals -node "d" units = "V", runits = "" -residual 3376 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 3384 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 3392 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 3400 4294967295 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 3408 3416 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 3424 3432 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 3440 3448 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 3456 3464 4294967295 4294967295 -node "gm" units = "V", runits = "" -residual 3472 3480 4294967295 4294967295 -node "bi" units = "V", runits = "" -residual 3488 3496 4294967295 4294967295 -node "sbulk" units = "V", runits = "" -residual 3504 3512 4294967295 4294967295 -node "dbulk" units = "V", runits = "" -residual 3520 3528 4294967295 4294967295 -node "N1" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "N2" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 696 -jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704 -jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712 -jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744 -jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752 -jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768 -jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800 -jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808 -jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816 -jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824 -jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832 -jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840 -jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856 -jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872 -jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880 -jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 888 -jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904 -jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920 -jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928 -jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936 -jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960 -jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "gm" units = "V", runits = "A" +node "bi" units = "V", runits = "A" +node "sbulk" units = "V", runits = "A" +node "dbulk" units = "V", runits = "A" +node "N1" units = "V", runits = "A" +node "N2" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (d, di) collapsible (s, si) collapsible (g, gm) @@ -1921,5 +1907,3 @@ noise "rbdb" (b, dbulk) noise "rbpd" (bi, dbulk) 0 states has bound_step false -instance size 4480 -model size 7176 diff --git a/openvaf/test_data/osdi/bsimbulk.snap b/openvaf/test_data/osdi/bsimbulk.snap index 2ae7496e9..93bf12b81 100644 --- a/openvaf/test_data/osdi/bsimbulk.snap +++ b/openvaf/test_data/osdi/bsimbulk.snap @@ -2094,127 +2094,113 @@ param "DELTAII" units = "V", desc = "Smoothing parameter", flags = ParameterFlags(0x0) 5 terminals -node "d" units = "V", runits = "" -residual 4080 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 4088 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 4096 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 4104 4294967295 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 4112 4120 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 4128 4136 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 4144 4152 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 4160 4168 4294967295 4294967295 -node "gm" units = "V", runits = "" -residual 4176 4184 4294967295 4294967295 -node "bi" units = "V", runits = "" -residual 4192 4200 4294967295 4294967295 -node "sbulk" units = "V", runits = "" -residual 4208 4216 4294967295 4294967295 -node "dbulk" units = "V", runits = "" -residual 4224 4232 4294967295 4294967295 -node "N1" units = "V", runits = "" -residual 4240 4248 4294967295 4294967295 -node "N2" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752 -jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784 -jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792 -jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800 -jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808 -jacobian (di, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816 -jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856 -jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872 -jacobian (si, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 880 -jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920 -jacobian (gi, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 928 -jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936 -jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960 -jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968 -jacobian (bi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976 -jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984 -jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992 -jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000 -jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1008 -jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016 -jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024 -jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032 -jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040 -jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048 -jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056 -jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064 -jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072 -jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080 -jacobian (N1, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1088 -jacobian (N1, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1096 -jacobian (N1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1104 -jacobian (N1, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1112 -jacobian (N1, bi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1120 -jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1128 -jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "gm" units = "V", runits = "A" +node "bi" units = "V", runits = "A" +node "sbulk" units = "V", runits = "A" +node "dbulk" units = "V", runits = "A" +node "N1" units = "V", runits = "A" +node "N2" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, N1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sbulk, sbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dbulk, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dbulk, dbulk) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (N1, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, bi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, N1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (N1, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (N2, N2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (t, gnd) collapsible (N1, gnd) collapsible (d, di) @@ -2244,5 +2230,3 @@ noise "rbdb" (b, dbulk) noise "rbpd" (bi, dbulk) 0 states has bound_step false -instance size 5336 -model size 8424 diff --git a/openvaf/test_data/osdi/bsimcmg.snap b/openvaf/test_data/osdi/bsimcmg.snap index 10f2bd8f5..babb19001 100644 --- a/openvaf/test_data/osdi/bsimcmg.snap +++ b/openvaf/test_data/osdi/bsimcmg.snap @@ -2130,99 +2130,88 @@ param "ALPHA_UFCM" units = "", desc = "Mobile charge scaling term taking QM effects into account", flags = ParameterFlags(0x0) 5 terminals -node "d" units = "V", runits = "" -residual 4320 4328 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 4336 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 4344 4352 4294967295 4294967295 -node "e" units = "V", runits = "" -residual 4360 4368 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 4376 4384 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 4392 4400 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 4408 4416 4294967295 4294967295 -node "ge" units = "V", runits = "" -residual 4424 4432 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 4440 4448 4294967295 4294967295 -node "q" units = "V", runits = "" -residual 4456 4464 4294967295 4294967295 -node "n" units = "V", runits = "" -residual 4472 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 600 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 608 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (s, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 632 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640 -jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648 -jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 -jacobian (e, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 672 -jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696 -jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720 -jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 728 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736 -jacobian (di, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752 -jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 784 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 792 -jacobian (si, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800 -jacobian (ge, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808 -jacobian (ge, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ge, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816 -jacobian (ge, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824 -jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 832 -jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840 -jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856 -jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888 -jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (gi, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, n) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 904 -jacobian (q, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (q, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920 -jacobian (q, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928 -jacobian (q, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936 -jacobian (q, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (q, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "e" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "ge" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "q" units = "V", runits = "A" +node "n" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (ge, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ge, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (ge, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, n) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (q, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (q, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (q, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (q, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (q, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (q, q) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) collapsible (d, di) collapsible (s, si) collapsible (ge, gi) @@ -2246,5 +2235,3 @@ noise "rg" (g, ge) noise "corl" (n, gnd) 0 states has bound_step false -instance size 5336 -model size 8584 diff --git a/openvaf/test_data/osdi/bsimimg.snap b/openvaf/test_data/osdi/bsimimg.snap index a5cf5e8fd..2ec36642b 100644 --- a/openvaf/test_data/osdi/bsimimg.snap +++ b/openvaf/test_data/osdi/bsimimg.snap @@ -1522,75 +1522,66 @@ param "PQSREF" units = "", desc = "P-term of QSREF", flags = ParameterFlags(0x0) 5 terminals -node "d" units = "V", runits = "" -residual 2888 4294967295 4294967295 4294967295 -node "fg" units = "V", runits = "" -residual 2896 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 2904 4294967295 4294967295 4294967295 -node "bg" units = "V", runits = "" -residual 4294967295 2912 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 2920 2928 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 2936 2944 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 2952 2960 4294967295 4294967295 -node "ge" units = "V", runits = "" -residual 2968 2976 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 2984 2992 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fg, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fg, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bg, bg) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 416 -jacobian (bg, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 424 -jacobian (bg, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 432 -jacobian (bg, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 440 -jacobian (bg, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 448 -jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456 -jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464 -jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 480 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488 -jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 496 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512 -jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536 -jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 544 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552 -jacobian (ge, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ge, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560 -jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568 -jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576 -jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584 -jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600 -jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 +node "d" units = "V", runits = "A" +node "fg" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "bg" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "ge" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fg, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fg, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bg, bg) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bg, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bg, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bg, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bg, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, ge) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, fg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ge, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ge, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, bg) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, ge) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (d, di) collapsible (s, si) collapsible (ge, gi) @@ -1609,5 +1600,3 @@ noise "Rs" (s, si) noise "Rg" (fg, ge) 0 states has bound_step false -instance size 3648 -model size 6144 diff --git a/openvaf/test_data/osdi/bsimsoi.snap b/openvaf/test_data/osdi/bsimsoi.snap index 782853d82..66767aabc 100644 --- a/openvaf/test_data/osdi/bsimsoi.snap +++ b/openvaf/test_data/osdi/bsimsoi.snap @@ -1994,128 +1994,115 @@ param "VTM00" units = "V", desc = "Hard coded 25 degC thermal voltage", flags = ParameterFlags(0x0) 7 terminals -node "d" units = "V", runits = "" -residual 4664 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 4672 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 4680 4294967295 4294967295 4294967295 -node "e" units = "V", runits = "" -residual 4294967295 4688 4294967295 4294967295 -node "p" units = "V", runits = "" -residual 4696 4704 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 4712 4720 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 4728 4736 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 4744 4752 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 4760 4768 4294967295 4294967295 -node "gi" units = "V", runits = "" -residual 4776 4784 4294967295 4294967295 -node "gm" units = "V", runits = "" -residual 4792 4800 4294967295 4294967295 -node "sb" units = "V", runits = "" -residual 4808 4816 4294967295 4294967295 -node "db" units = "V", runits = "" -residual 4824 4832 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 776 -jacobian (e, p) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 784 -jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792 -jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 800 -jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808 -jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816 -jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 824 -jacobian (e, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 832 -jacobian (p, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (p, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840 -jacobian (p, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (p, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 856 -jacobian (p, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (p, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (p, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (b, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880 -jacobian (b, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888 -jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904 -jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (b, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 920 -jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928 -jacobian (t, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (di, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960 -jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968 -jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992 -jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000 -jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1008 -jacobian (di, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024 -jacobian (si, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032 -jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040 -jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064 -jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072 -jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1080 -jacobian (si, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088 -jacobian (si, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096 -jacobian (gi, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104 -jacobian (gi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112 -jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120 -jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128 -jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1136 -jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144 -jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152 -jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160 -jacobian (gm, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168 -jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176 -jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184 -jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192 -jacobian (sb, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200 -jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208 -jacobian (sb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216 -jacobian (sb, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224 -jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232 -jacobian (db, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240 -jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248 -jacobian (db, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256 -jacobian (db, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264 -jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "e" units = "V", runits = "A" +node "p" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "di" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "gi" units = "V", runits = "A" +node "gm" units = "V", runits = "A" +node "sb" units = "V", runits = "A" +node "db" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, p) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, gi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (p, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (p, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (p, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (p, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (p, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (p, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (p, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gm) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gm, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, gi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gm, gm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, p) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (b, gnd) collapsible (p, gnd) collapsible (d, di) @@ -2145,5 +2132,3 @@ noise "rbdb" (b, db) noise "rbsb" (b, sb) 0 states has bound_step false -instance size 6064 -model size 8024 diff --git a/openvaf/test_data/osdi/cccs.snap b/openvaf/test_data/osdi/cccs.snap index 4381d66ee..24d8b67fe 100644 --- a/openvaf/test_data/osdi/cccs.snap +++ b/openvaf/test_data/osdi/cccs.snap @@ -8,27 +8,21 @@ param "Rout" units = "Ohm", desc = "output Resistance", flags = ParameterFlags(0x0) 4 terminals -node "Inp" units = "V", runits = "" -residual 184 4294967295 4294967295 4294967295 -node "Inm" units = "V", runits = "" -residual 192 4294967295 4294967295 4294967295 -node "Outp" units = "V", runits = "" -residual 200 4294967295 4294967295 4294967295 -node "Outm" units = "V", runits = "" -residual 208 4294967295 4294967295 4294967295 -node(flow) "flow(br_in)" units = "A", runits = "" -residual 216 4294967295 4294967295 4294967295 -jacobian (Inp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(br_in), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(br_in), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(br_in), flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "Inp" units = "V", runits = "A" +node "Inm" units = "V", runits = "A" +node "Outp" units = "V", runits = "A" +node "Outm" units = "V", runits = "A" +node(flow) "flow(br_in)" units = "A", runits = "A" +jacobian (Inp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(br_in), Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(br_in), Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(br_in), flow(br_in)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 224 -model size 40 diff --git a/openvaf/test_data/osdi/current_source.snap b/openvaf/test_data/osdi/current_source.snap index 6861586b8..4a5fa09fb 100644 --- a/openvaf/test_data/osdi/current_source.snap +++ b/openvaf/test_data/osdi/current_source.snap @@ -6,15 +6,11 @@ param "R" units = "Ohm", desc = "Output Resistance", flags = ParameterFlags(0x0) 2 terminals -node "Np" units = "V", runits = "" -residual 88 4294967295 4294967295 4294967295 -node "Nm" units = "V", runits = "" -residual 96 4294967295 4294967295 4294967295 -jacobian (Np, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Np, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Nm, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Nm, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "Np" units = "V", runits = "A" +node "Nm" units = "V", runits = "A" +jacobian (Np, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Np, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Nm, Np) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Nm, Nm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 104 -model size 32 diff --git a/openvaf/test_data/osdi/diode.snap b/openvaf/test_data/osdi/diode.snap index e56adf83c..f71194ff1 100644 --- a/openvaf/test_data/osdi/diode.snap +++ b/openvaf/test_data/osdi/diode.snap @@ -28,33 +28,27 @@ param "minr" units = "Ohm", desc = "minr is the value below which the simulator expects elimination of resitance and it will improve simulation efficiency without significantly altering the results.", flags = ParameterFlags(0x0) 3 terminals -node "A" units = "V", runits = "" -residual 248 256 4294967295 4294967295 -node "C" units = "V", runits = "" -residual 264 4294967295 4294967295 4294967295 -node "dT" units = "K", runits = "" -residual 272 4294967295 4294967295 4294967295 -node "CI" units = "V", runits = "" -residual 280 288 4294967295 4294967295 -jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 120 -jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 128 -jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 136 -jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 144 -jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 152 -jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 160 +node "A" units = "V", runits = "A" +node "C" units = "V", runits = "A" +node "dT" units = "K", runits = "W" +node "CI" units = "V", runits = "A" +jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (CI, C) collapsible (dT, gnd) noise "unnamed0" (A, CI) noise "unnamed1" (CI, C) 0 states has bound_step false -instance size 456 -model size 120 diff --git a/openvaf/test_data/osdi/diode_cmc.snap b/openvaf/test_data/osdi/diode_cmc.snap index fc4644dc2..d86e6c3cc 100644 --- a/openvaf/test_data/osdi/diode_cmc.snap +++ b/openvaf/test_data/osdi/diode_cmc.snap @@ -206,40 +206,34 @@ param "MULT" units = "", desc = "", flags = ParameterFlags(0x0) 2 terminals -node "A" units = "V", runits = "" -residual 1616 1624 4294967295 4294967295 -node "K" units = "V", runits = "" -residual 1632 4294967295 4294967295 4294967295 -node "AIK" units = "V", runits = "" -residual 1640 1648 4294967295 4294967295 -node "charge_A" units = "V", runits = "" -residual 1656 1664 4294967295 4294967295 -node "charge_K" units = "V", runits = "" -residual 1672 1680 4294967295 4294967295 -node "depl_A" units = "V", runits = "" -residual 1688 1696 4294967295 4294967295 -jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 184 -jacobian (A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 192 -jacobian (A, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 200 -jacobian (A, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 208 -jacobian (A, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 216 -jacobian (K, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (AIK, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 224 -jacobian (AIK, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (AIK, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 232 -jacobian (AIK, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 240 -jacobian (AIK, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 248 -jacobian (AIK, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 256 -jacobian (charge_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264 -jacobian (charge_K, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272 -jacobian (depl_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (depl_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 280 +node "A" units = "V", runits = "A" +node "K" units = "V", runits = "A" +node "AIK" units = "V", runits = "A" +node "charge_A" units = "V", runits = "A" +node "charge_K" units = "V", runits = "A" +node "depl_A" units = "V", runits = "A" +jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (A, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (A, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (A, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (K, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (AIK, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (AIK, K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (AIK, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (AIK, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (AIK, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (AIK, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (charge_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (charge_K, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_K, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (depl_A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (depl_A, AIK) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (AIK, K) collapsible (charge_A, gnd) collapsible (charge_K, gnd) @@ -249,5 +243,3 @@ noise "flicker" (A, AIK) noise "thermal" (AIK, K) 0 states has bound_step false -instance size 1856 -model size 840 diff --git a/openvaf/test_data/osdi/diode_lim.snap b/openvaf/test_data/osdi/diode_lim.snap index 260bfdc38..ff1c50b3e 100644 --- a/openvaf/test_data/osdi/diode_lim.snap +++ b/openvaf/test_data/osdi/diode_lim.snap @@ -29,30 +29,24 @@ units = "Ohm", desc = "minr is the value below which the simulator expects elimi 3 terminals node "A" units = "V", runits = "A" -residual 216 224 232 240 node "C" units = "V", runits = "A" -residual 248 4294967295 4294967295 4294967295 node "dT" units = "K", runits = "W" -residual 256 4294967295 264 4294967295 node "CI" units = "V", runits = "A" -residual 272 280 288 296 -jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 120 -jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 128 -jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 136 -jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 144 +jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (A, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (A, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (C, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (C, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (C, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dT, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (CI, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (CI, C) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (CI, dT) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (CI, CI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (CI, C) collapsible (dT, gnd) 1 states has bound_step false -instance size 400 -model size 120 diff --git a/openvaf/test_data/osdi/ekv.snap b/openvaf/test_data/osdi/ekv.snap index 0a1553c12..de3e4397b 100644 --- a/openvaf/test_data/osdi/ekv.snap +++ b/openvaf/test_data/osdi/ekv.snap @@ -152,53 +152,45 @@ param "tp_njtsswg" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 904 912 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 4294967295 920 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 928 936 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 944 952 4294967295 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" node "implicit_equation_0" units = "", runits = "" -residual 960 968 4294967295 4294967295 node "implicit_equation_1" units = "", runits = "" -residual 976 984 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 264 -jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 272 -jacobian (d, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 280 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 288 -jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 296 -jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 304 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 312 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 320 -jacobian (s, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 328 -jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 336 -jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 344 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 352 -jacobian (b, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_0, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 360 -jacobian (implicit_equation_0, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 368 -jacobian (implicit_equation_0, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 376 -jacobian (implicit_equation_0, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 384 -jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 392 -jacobian (implicit_equation_1, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 400 -jacobian (implicit_equation_1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 408 -jacobian (implicit_equation_1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 416 -jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_0, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_1, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) noise "thermal" (d, s) noise "flicker" (d, s) 0 states has bound_step false -instance size 1296 -model size 616 diff --git a/openvaf/test_data/osdi/ekv_longchannel.snap b/openvaf/test_data/osdi/ekv_longchannel.snap index b48dc9170..34ef76b48 100644 --- a/openvaf/test_data/osdi/ekv_longchannel.snap +++ b/openvaf/test_data/osdi/ekv_longchannel.snap @@ -16,23 +16,17 @@ param "THETA" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 112 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 120 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 192 -model size 72 diff --git a/openvaf/test_data/osdi/hicuml2.snap b/openvaf/test_data/osdi/hicuml2.snap index c45bc9fff..03742c14b 100644 --- a/openvaf/test_data/osdi/hicuml2.snap +++ b/openvaf/test_data/osdi/hicuml2.snap @@ -274,134 +274,117 @@ param "type" units = "", desc = "", flags = ParameterFlags(PARA_TY_INT) 5 terminals -node "c" units = "V", runits = "" -residual 2376 2384 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 2392 2400 4294967295 4294967295 -node "e" units = "V", runits = "" -residual 2408 2416 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 2424 2432 4294967295 4294967295 -node "tnode" units = "V", runits = "" -residual 2440 2448 4294967295 4294967295 -node "ci" units = "V", runits = "" -residual 2456 2464 4294967295 4294967295 -node "ei" units = "V", runits = "" -residual 2472 2480 4294967295 4294967295 -node "bp" units = "V", runits = "" -residual 2488 2496 4294967295 4294967295 -node "bi" units = "V", runits = "" -residual 2504 2512 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 2520 2528 4294967295 4294967295 -node "xf1" units = "V", runits = "" -residual 2536 2544 4294967295 4294967295 -node "xf2" units = "V", runits = "" -residual 2552 2560 4294967295 4294967295 -node "xf" units = "V", runits = "" -residual 2568 2576 4294967295 4294967295 -node "n1" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "n2" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 +node "c" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "e" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "tnode" units = "V", runits = "A" +node "ci" units = "V", runits = "A" +node "ei" units = "V", runits = "A" +node "bp" units = "V", runits = "A" +node "bi" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "xf1" units = "V", runits = "A" +node "xf2" units = "V", runits = "A" +node "xf" units = "V", runits = "A" +node "n1" units = "V", runits = "A" +node "n2" units = "V", runits = "A" node "implicit_equation_0" units = "", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 node "implicit_equation_1" units = "", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (c, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 768 -jacobian (c, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (c, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784 -jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792 -jacobian (b, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 800 -jacobian (b, ci) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 808 -jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 816 -jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824 -jacobian (e, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, bp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 832 -jacobian (s, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 840 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (s, tnode) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (tnode, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 872 -jacobian (tnode, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tnode, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ci, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ci, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 880 -jacobian (ci, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888 -jacobian (ci, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (ci, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904 -jacobian (ci, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (ci, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920 -jacobian (ci, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928 -jacobian (ci, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ci, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 936 -jacobian (ei, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (ei, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (ei, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960 -jacobian (ei, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968 -jacobian (ei, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 976 -jacobian (ei, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (ei, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bp, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 984 -jacobian (bp, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992 -jacobian (bp, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000 -jacobian (bp, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1008 -jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016 -jacobian (bp, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024 -jacobian (bp, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032 -jacobian (bi, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040 -jacobian (bi, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048 -jacobian (bi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056 -jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064 -jacobian (bi, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1072 -jacobian (bi, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bi, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080 -jacobian (si, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088 -jacobian (si, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096 -jacobian (si, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104 -jacobian (xf1, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf1, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf1, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf1, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf1, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112 -jacobian (xf1, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf2, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120 -jacobian (xf, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xf, xf) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128 -jacobian (n1, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (n2, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_0, n1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1136 -jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_1, n2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1144 -jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (c, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, ci) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, bp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, tnode) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (tnode, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (tnode, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tnode, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ci, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ci, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (ci, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ci, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ci, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ei, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ei, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ei, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ei, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (ei, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (ei, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (ei, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bp, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bi, xf) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bi, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bi, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (xf1, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf1, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf1, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf1, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf1, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (xf1, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, xf1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf2, xf2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (xf, tnode) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf, ci) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf, ei) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf, bi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xf, xf) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (n1, n1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (n2, n2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_0, n1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_1, n2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (implicit_equation_1, implicit_equation_1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (implicit_equation_0, gnd) collapsible (implicit_equation_1, gnd) collapsible (b, bp) @@ -429,5 +412,3 @@ noise "ibei" (n1, gnd) noise "it" (n2, gnd) 0 states has bound_step false -instance size 3560 -model size 1112 diff --git a/openvaf/test_data/osdi/hisim2.snap b/openvaf/test_data/osdi/hisim2.snap index ca0c37381..0a6cebd61 100644 --- a/openvaf/test_data/osdi/hisim2.snap +++ b/openvaf/test_data/osdi/hisim2.snap @@ -1376,94 +1376,81 @@ param "PSLIMPT" units = "V", desc = "Ps0 limit for deep punchthrough ", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 3688 4294967295 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 3696 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 3704 4294967295 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 3712 4294967295 4294967295 4294967295 -node "dp" units = "V", runits = "" -residual 3720 3728 4294967295 4294967295 -node "gp" units = "V", runits = "" -residual 3736 3744 4294967295 4294967295 -node "sp" units = "V", runits = "" -residual 3752 3760 4294967295 4294967295 -node "bp" units = "V", runits = "" -residual 3768 3776 4294967295 4294967295 -node "db" units = "V", runits = "" -residual 3784 3792 4294967295 4294967295 -node "sb" units = "V", runits = "" -residual 3800 3808 4294967295 4294967295 -node "n" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "int_nqs_b" units = "V", runits = "" -residual 3816 3824 4294967295 4294967295 -node "int_nqs_i" units = "V", runits = "" -residual 3832 3840 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504 -jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512 -jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520 -jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528 -jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536 -jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 544 -jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552 -jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560 -jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568 -jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576 -jacobian (gp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584 -jacobian (gp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 592 -jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600 -jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 -jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 640 -jacobian (sp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 648 -jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 -jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672 -jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696 -jacobian (bp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 704 -jacobian (bp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 712 -jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 720 -jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 728 -jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736 -jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744 -jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 752 -jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_b, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_b, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_b, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_b, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 768 -jacobian (int_nqs_i, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_i, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_i, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_i, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (int_nqs_i, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "dp" units = "V", runits = "A" +node "gp" units = "V", runits = "A" +node "sp" units = "V", runits = "A" +node "bp" units = "V", runits = "A" +node "db" units = "V", runits = "A" +node "sb" units = "V", runits = "A" +node "n" units = "V", runits = "A" +node "int_nqs_b" units = "V", runits = "A" +node "int_nqs_i" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (db, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_b, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_b, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_b, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_b, int_nqs_b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (int_nqs_i, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_i, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_i, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_i, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (int_nqs_i, int_nqs_i) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (d, dp) collapsible (sp, s) collapsible (g, gp) @@ -1480,5 +1467,3 @@ noise "isource" (sp, s) noise "unnamed1" (n, gnd) 0 states has bound_step false -instance size 4416 -model size 5480 diff --git a/openvaf/test_data/osdi/hisimhv.snap b/openvaf/test_data/osdi/hisimhv.snap index fe0b90252..567eb8fb5 100644 --- a/openvaf/test_data/osdi/hisimhv.snap +++ b/openvaf/test_data/osdi/hisimhv.snap @@ -1724,174 +1724,155 @@ param "PVDIFFJS" units = "-", desc = "Cross-term dependence of vdiffjs )", flags = ParameterFlags(0x0) 6 terminals -node "d" units = "V", runits = "" -residual 5776 5784 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 5792 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 5800 5808 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 5816 4294967295 4294967295 4294967295 -node "sub" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "temp" units = "V", runits = "" -residual 5824 5832 4294967295 4294967295 -node "dp" units = "V", runits = "" -residual 5840 5848 4294967295 4294967295 -node "gp" units = "V", runits = "" -residual 5856 5864 4294967295 4294967295 -node "sp" units = "V", runits = "" -residual 5872 5880 4294967295 4294967295 -node "bp" units = "V", runits = "" -residual 5888 5896 4294967295 4294967295 -node "db" units = "V", runits = "" -residual 5904 5912 4294967295 4294967295 -node "sb" units = "V", runits = "" -residual 5920 5928 4294967295 4294967295 -node "qi" units = "V", runits = "" -residual 5936 5944 4294967295 4294967295 -node "qb" units = "V", runits = "" -residual 5952 5960 4294967295 4294967295 -node "qbd" units = "V", runits = "" -residual 5968 5976 4294967295 4294967295 -node "n" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "charge_A" units = "V", runits = "" -residual 5984 5992 4294967295 4294967295 -node "charge_K" units = "V", runits = "" -residual 6000 6008 4294967295 4294967295 -node "depl_A" units = "V", runits = "" -residual 6016 6024 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056 -jacobian (d, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064 -jacobian (d, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072 -jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080 -jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088 -jacobian (d, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096 -jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104 -jacobian (d, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112 -jacobian (d, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1120 -jacobian (d, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1128 -jacobian (d, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1136 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152 -jacobian (s, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160 -jacobian (s, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168 -jacobian (s, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176 -jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184 -jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192 -jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200 -jacobian (s, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216 -jacobian (temp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (temp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224 -jacobian (dp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232 -jacobian (dp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240 -jacobian (dp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248 -jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256 -jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264 -jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272 -jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280 -jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1288 -jacobian (dp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1296 -jacobian (dp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1304 -jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1312 -jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1320 -jacobian (gp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1328 -jacobian (gp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1336 -jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1344 -jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1352 -jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1360 -jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1368 -jacobian (gp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1376 -jacobian (gp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1384 -jacobian (gp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1392 -jacobian (sp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1400 -jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1408 -jacobian (sp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1416 -jacobian (sp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1424 -jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1432 -jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1440 -jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1448 -jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1456 -jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1464 -jacobian (sp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1472 -jacobian (sp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1480 -jacobian (sp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1488 -jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1496 -jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1504 -jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (bp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1512 -jacobian (bp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1520 -jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528 -jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536 -jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1544 -jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1552 -jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560 -jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1568 -jacobian (bp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1576 -jacobian (bp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584 -jacobian (bp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592 -jacobian (db, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600 -jacobian (db, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1608 -jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1616 -jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1624 -jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1632 -jacobian (db, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640 -jacobian (db, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648 -jacobian (db, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1656 -jacobian (sb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1664 -jacobian (sb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1672 -jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1680 -jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1688 -jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1696 -jacobian (qi, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qi, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qi, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qi, qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1704 -jacobian (qb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qb, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qb, qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1712 -jacobian (qbd, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (qbd, qbd) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1720 -jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1728 -jacobian (charge_K, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_K, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_K, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1736 -jacobian (depl_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (depl_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1744 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "sub" units = "V", runits = "A" +node "temp" units = "V", runits = "A" +node "dp" units = "V", runits = "A" +node "gp" units = "V", runits = "A" +node "sp" units = "V", runits = "A" +node "bp" units = "V", runits = "A" +node "db" units = "V", runits = "A" +node "sb" units = "V", runits = "A" +node "qi" units = "V", runits = "A" +node "qb" units = "V", runits = "A" +node "qbd" units = "V", runits = "A" +node "n" units = "V", runits = "A" +node "charge_A" units = "V", runits = "A" +node "charge_K" units = "V", runits = "A" +node "depl_A" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (temp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (temp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dp, db) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (dp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (dp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (dp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sp, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (bp, sub) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, qbd) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (db, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, dp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (db, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (db, charge_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (db, charge_K) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (db, depl_A) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, sp) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (sb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (sb, sb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (qi, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qi, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qi, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qi, qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (qb, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qb, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qb, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qb, qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (qbd, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, sub) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, dp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, sp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (qbd, qbd) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_A, charge_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (charge_K, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_K, temp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_K, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (charge_K, charge_K) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (depl_A, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (depl_A, db) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (depl_A, depl_A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (sub, temp) collapsible (charge_A, gnd) collapsible (charge_K, gnd) @@ -1915,5 +1896,3 @@ noise "isource" (sp, s) noise "unnamed1" (n, gnd) 0 states has bound_step false -instance size 7424 -model size 6848 diff --git a/openvaf/test_data/osdi/hisimsotb.snap b/openvaf/test_data/osdi/hisimsotb.snap index 5958633bc..86b29b050 100644 --- a/openvaf/test_data/osdi/hisimsotb.snap +++ b/openvaf/test_data/osdi/hisimsotb.snap @@ -632,93 +632,82 @@ param "TN" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 2248 2256 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 2264 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 2272 2280 4294967295 4294967295 -node "e" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "t" units = "K", runits = "" -residual 2288 2296 4294967295 4294967295 -node "gp" units = "V", runits = "" -residual 2304 2312 4294967295 4294967295 -node "bp" units = "V", runits = "" -residual 2320 2328 4294967295 4294967295 -node "n" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -node "nqs_qi" units = "V", runits = "" -residual 2336 2344 4294967295 4294967295 -node "nqs_qb" units = "V", runits = "" -residual 2352 2360 4294967295 4294967295 -node "nqs_qhs" units = "V", runits = "" -residual 2368 2376 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528 -jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 536 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544 -jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552 -jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560 -jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568 -jacobian (d, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 576 -jacobian (d, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 600 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 -jacobian (s, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 640 -jacobian (s, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 648 -jacobian (s, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 -jacobian (t, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (t, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672 -jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (gp, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696 -jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704 -jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712 -jacobian (gp, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 720 -jacobian (gp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 728 -jacobian (gp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 736 -jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 744 -jacobian (bp, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 752 -jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 760 -jacobian (bp, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 768 -jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 776 -jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 784 -jacobian (bp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 792 -jacobian (bp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 800 -jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qi, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 808 -jacobian (nqs_qi, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qb, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 816 -jacobian (nqs_qb, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (nqs_qhs, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 824 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "e" units = "V", runits = "A" +node "t" units = "K", runits = "W" +node "gp" units = "V", runits = "A" +node "bp" units = "V", runits = "A" +node "n" units = "V", runits = "A" +node "nqs_qi" units = "V", runits = "A" +node "nqs_qb" units = "V", runits = "A" +node "nqs_qhs" units = "V", runits = "A" +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (t, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (t, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gp, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, g) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, t) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (bp, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (bp, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (n, n) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qi, nqs_qi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (nqs_qi, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qb, nqs_qb) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (nqs_qb, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, t) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, gp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, bp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (nqs_qhs, nqs_qhs) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (g, gp) collapsible (e, bp) collapsible (t, gnd) @@ -733,5 +722,3 @@ noise "iigb" (gp, bp) noise "unnamed1" (n, gnd) 0 states has bound_step false -instance size 3056 -model size 2480 diff --git a/openvaf/test_data/osdi/mextram.snap b/openvaf/test_data/osdi/mextram.snap index 37190cc49..4d1e491e5 100644 --- a/openvaf/test_data/osdi/mextram.snap +++ b/openvaf/test_data/osdi/mextram.snap @@ -244,138 +244,130 @@ param "gmin" units = "", desc = "Minimum conductance", flags = ParameterFlags(0x0) 5 terminals -node "c" units = "V", runits = "" -residual 2616 2624 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 2632 2640 4294967295 4294967295 -node "e" units = "V", runits = "" -residual 2648 2656 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 2664 2672 4294967295 4294967295 -node "dt" units = "V", runits = "" -residual 2680 2688 4294967295 4294967295 -node "e1" units = "V", runits = "" -residual 2696 2704 4294967295 4294967295 -node "b1" units = "V", runits = "" -residual 2712 2720 4294967295 4294967295 -node "b2" units = "V", runits = "" -residual 2728 2736 4294967295 4294967295 -node "c1" units = "V", runits = "" -residual 2744 2752 4294967295 4294967295 -node "c2" units = "V", runits = "" -residual 2760 2768 4294967295 4294967295 -node "c3" units = "V", runits = "" -residual 2776 2784 4294967295 4294967295 -node "c4" units = "V", runits = "" -residual 2792 2800 4294967295 4294967295 -node "noi" units = "V", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 +node "c" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "e" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "dt" units = "V", runits = "A" +node "e1" units = "V", runits = "A" +node "b1" units = "V", runits = "A" +node "b2" units = "V", runits = "A" +node "c1" units = "V", runits = "A" +node "c2" units = "V", runits = "A" +node "c3" units = "V", runits = "A" +node "c4" units = "V", runits = "A" +node "noi" units = "V", runits = "A" node "implicit_equation_0" units = "", runits = "" -residual 4294967295 4294967295 4294967295 4294967295 -jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 840 -jacobian (c, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 848 -jacobian (c, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 856 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 864 -jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 872 -jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 880 -jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 888 -jacobian (b, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 896 -jacobian (b, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 904 -jacobian (b, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 912 -jacobian (b, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 920 -jacobian (b, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 928 -jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 936 -jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 944 -jacobian (e, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 952 -jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 960 -jacobian (s, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 968 -jacobian (s, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 976 -jacobian (dt, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e1, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 984 -jacobian (e1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 992 -jacobian (e1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1000 -jacobian (e1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1008 -jacobian (e1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1016 -jacobian (e1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1024 -jacobian (e1, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (e1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1032 -jacobian (b1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1040 -jacobian (b1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1048 -jacobian (b1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1056 -jacobian (b1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1064 -jacobian (b1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1072 -jacobian (b1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1080 -jacobian (b2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1088 -jacobian (b2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1096 -jacobian (b2, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1104 -jacobian (b2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1112 -jacobian (b2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1120 -jacobian (b2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1128 -jacobian (b2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b2, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c1, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1136 -jacobian (c1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1144 -jacobian (c1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1152 -jacobian (c1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1160 -jacobian (c1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1168 -jacobian (c1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1176 -jacobian (c1, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1184 -jacobian (c1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1192 -jacobian (c2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1200 -jacobian (c2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1208 -jacobian (c2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1216 -jacobian (c2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1224 -jacobian (c2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1232 -jacobian (c2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c3, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c3, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1240 -jacobian (c3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1248 -jacobian (c3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1256 -jacobian (c3, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1264 -jacobian (c3, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1272 -jacobian (c3, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1280 -jacobian (c3, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1288 -jacobian (c3, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1296 -jacobian (c4, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (c4, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1304 -jacobian (c4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1312 -jacobian (c4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1320 -jacobian (c4, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1328 -jacobian (c4, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1336 -jacobian (c4, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1344 -jacobian (c4, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1352 -jacobian (c4, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1360 -jacobian (noi, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (implicit_equation_0, noi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 1368 -jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (c, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, c) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, e) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (e, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dt, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e1, e) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (e1, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (e1, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (b2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b2, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c1, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c1, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c1, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, e1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c2, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c3, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c3, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c3, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, c) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (c4, b) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, b1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, b2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, c1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, c2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, c3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (c4, c4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (noi, noi) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_0, noi) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (implicit_equation_0, implicit_equation_0) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (c4, c1) collapsible (c3, c4) noise "ib1e1_f" (b1, e1) @@ -406,5 +398,3 @@ noise "rcc" (c, c1) noise "in" (noi, gnd) 0 states has bound_step false -instance size 4264 -model size 960 diff --git a/openvaf/test_data/osdi/mvsg_cmc.snap b/openvaf/test_data/osdi/mvsg_cmc.snap index 809cde9d4..5efafea9c 100644 --- a/openvaf/test_data/osdi/mvsg_cmc.snap +++ b/openvaf/test_data/osdi/mvsg_cmc.snap @@ -510,246 +510,221 @@ param "minc" units = "F", desc = "Minimum capacitance", flags = ParameterFlags(0x0) 4 terminals -node "d" units = "V", runits = "" -residual 3560 3568 4294967295 4294967295 -node "g" units = "V", runits = "" -residual 3576 4294967295 4294967295 4294967295 -node "s" units = "V", runits = "" -residual 3584 3592 4294967295 4294967295 -node "b" units = "V", runits = "" -residual 4294967295 3600 4294967295 4294967295 -node "di" units = "V", runits = "" -residual 3608 3616 4294967295 4294967295 -node "gi1" units = "V", runits = "" -residual 3624 3632 4294967295 4294967295 -node "gi2" units = "V", runits = "" -residual 3640 3648 4294967295 4294967295 -node "si" units = "V", runits = "" -residual 3656 3664 4294967295 4294967295 -node "fps1" units = "V", runits = "" -residual 3672 3680 4294967295 4294967295 -node "fps2" units = "V", runits = "" -residual 3688 3696 4294967295 4294967295 -node "fps3" units = "V", runits = "" -residual 3704 3712 4294967295 4294967295 -node "fps4" units = "V", runits = "" -residual 3720 3728 4294967295 4294967295 -node "fp1" units = "V", runits = "" -residual 3736 3744 4294967295 4294967295 -node "fp2" units = "V", runits = "" -residual 3752 3760 4294967295 4294967295 -node "fp3" units = "V", runits = "" -residual 3768 3776 4294967295 4294967295 -node "fp4" units = "V", runits = "" -residual 3784 3792 4294967295 4294967295 -node "drc" units = "V", runits = "" -residual 3800 4294967295 4294967295 4294967295 -node "src" units = "V", runits = "" -residual 3808 4294967295 4294967295 4294967295 -node "tr" units = "V", runits = "" -residual 3816 3824 4294967295 4294967295 -node "tr1" units = "V", runits = "" -residual 3832 3840 4294967295 4294967295 -node "xt1" units = "V", runits = "" -residual 3848 3856 4294967295 4294967295 -node "xt2" units = "V", runits = "" -residual 3864 3872 4294967295 4294967295 -node "dt" units = "K", runits = "" -residual 3880 3888 4294967295 4294967295 +node "d" units = "V", runits = "A" +node "g" units = "V", runits = "A" +node "s" units = "V", runits = "A" +node "b" units = "V", runits = "A" +node "di" units = "V", runits = "A" +node "gi1" units = "V", runits = "A" +node "gi2" units = "V", runits = "A" +node "si" units = "V", runits = "A" +node "fps1" units = "V", runits = "A" +node "fps2" units = "V", runits = "A" +node "fps3" units = "V", runits = "A" +node "fps4" units = "V", runits = "A" +node "fp1" units = "V", runits = "A" +node "fp2" units = "V", runits = "A" +node "fp3" units = "V", runits = "A" +node "fp4" units = "V", runits = "A" +node "drc" units = "V", runits = "A" +node "src" units = "V", runits = "A" +node "tr" units = "V", runits = "A" +node "tr1" units = "V", runits = "A" +node "xt1" units = "V", runits = "A" +node "xt2" units = "V", runits = "A" +node "dt" units = "K", runits = "W" node(flow) "flow(d,drc)" units = "A", runits = "" -residual 3896 4294967295 4294967295 4294967295 node(flow) "flow(src,s)" units = "A", runits = "" -residual 3904 4294967295 4294967295 4294967295 -jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1528 -jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1536 -jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1544 -jacobian (d, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1552 -jacobian (d, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (d, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (g, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1560 -jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1568 -jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1576 -jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1584 -jacobian (s, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1592 -jacobian (s, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1600 -jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1608 -jacobian (s, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1616 -jacobian (s, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1624 -jacobian (s, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1632 -jacobian (s, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1640 -jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1648 -jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1656 -jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1664 -jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1672 -jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1680 -jacobian (s, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1688 -jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1696 -jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1704 -jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1712 -jacobian (b, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1720 -jacobian (b, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1728 -jacobian (b, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1736 -jacobian (b, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1744 -jacobian (b, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1752 -jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1760 -jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1768 -jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1776 -jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1784 -jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1792 -jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1800 -jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1808 -jacobian (di, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1816 -jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1824 -jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1832 -jacobian (di, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1840 -jacobian (gi1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1848 -jacobian (gi1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1856 -jacobian (gi1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1864 -jacobian (gi1, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1872 -jacobian (gi1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi2, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1880 -jacobian (gi2, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1888 -jacobian (gi2, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (gi2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1896 -jacobian (gi2, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1904 -jacobian (gi2, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1912 -jacobian (gi2, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1920 -jacobian (gi2, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1928 -jacobian (gi2, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1936 -jacobian (gi2, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1944 -jacobian (gi2, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1952 -jacobian (gi2, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1960 -jacobian (gi2, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 1968 -jacobian (gi2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1976 -jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1984 -jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 1992 -jacobian (si, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2000 -jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2008 -jacobian (si, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2016 -jacobian (si, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2024 -jacobian (si, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2032 -jacobian (si, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2040 -jacobian (si, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2048 -jacobian (si, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2056 -jacobian (si, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2064 -jacobian (si, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2072 -jacobian (fps1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2080 -jacobian (fps1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2088 -jacobian (fps1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2096 -jacobian (fps1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2104 -jacobian (fps1, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2112 -jacobian (fps1, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2120 -jacobian (fps1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2128 -jacobian (fps2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2136 -jacobian (fps2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2144 -jacobian (fps2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2152 -jacobian (fps2, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2160 -jacobian (fps2, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2168 -jacobian (fps2, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2176 -jacobian (fps2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2184 -jacobian (fps3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2192 -jacobian (fps3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2200 -jacobian (fps3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2208 -jacobian (fps3, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2216 -jacobian (fps3, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2224 -jacobian (fps3, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2232 -jacobian (fps3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2240 -jacobian (fps4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fps4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2248 -jacobian (fps4, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2256 -jacobian (fps4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2264 -jacobian (fps4, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2272 -jacobian (fps4, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2280 -jacobian (fps4, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fps4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2288 -jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2296 -jacobian (fp1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2304 -jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2312 -jacobian (fp1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2320 -jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2328 -jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2336 -jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2344 -jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2352 -jacobian (fp2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2360 -jacobian (fp2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2368 -jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2376 -jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2384 -jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2392 -jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2400 -jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2408 -jacobian (fp3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2416 -jacobian (fp3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2424 -jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2432 -jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2440 -jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2448 -jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2456 -jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2464 -jacobian (fp4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2472 -jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2480 -jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2488 -jacobian (fp4, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fp4, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2496 -jacobian (drc, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (drc, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (src, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tr, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2504 -jacobian (tr, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2512 -jacobian (tr1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tr1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (tr1, tr) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2520 -jacobian (tr1, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2528 -jacobian (xt1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt1, xt1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 2536 -jacobian (xt1, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt2, xt1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (xt2, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2544 -jacobian (dt, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 2552 -jacobian (flow(d,drc), d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(d,drc), drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(d,drc), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(d,drc), flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(src,s), s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(src,s), src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(src,s), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (flow(src,s), flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +jacobian (d, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (d, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (d, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (d, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (g, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (s, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, si) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (s, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (s, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (b, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, di) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, gi1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (b, dt) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (di, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (di, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (di, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi1, d) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi1, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi1, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi2, s) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi2, gi1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (gi2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi2, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (gi2, fps1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, fp4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (gi2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (si, fps2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, fps3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, fps4) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, fp1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, fp2) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, fp3) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (si, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (si, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fps1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fps2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fps3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fps4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps4, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fps4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps4, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps4, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fps4, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fps4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp2, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp2, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, b) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (fp3, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp3, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fp4, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (fp4, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fp4, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (fp4, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (drc, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (drc, flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (src, flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tr, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (tr, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (tr1, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tr1, g) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (tr1, tr) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (tr1, tr1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (xt1, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt1, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt1, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt1, xt1) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (xt1, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt1, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt2, xt1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (xt2, xt2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (dt, d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, di) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, gi2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, si) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fps1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fps2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fps3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fps4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp1) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp3) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, fp4) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, tr) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (dt, dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(d,drc), d) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(d,drc), drc) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(d,drc), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(d,drc), flow(d,drc)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(src,s), s) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(src,s), src) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(src,s), dt) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (flow(src,s), flow(src,s)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) collapsible (tr1, gnd) collapsible (tr, gnd) collapsible (fp4, fp3) @@ -787,5 +762,3 @@ noise "rcd" (flow(d,drc), gnd) noise "rcs" (flow(src,s), gnd) 0 states has bound_step false -instance size 5840 -model size 2072 diff --git a/openvaf/test_data/osdi/noise.snap b/openvaf/test_data/osdi/noise.snap index 2f8a138d0..07cd51887 100644 --- a/openvaf/test_data/osdi/noise.snap +++ b/openvaf/test_data/osdi/noise.snap @@ -7,14 +7,10 @@ units = "", desc = "", flags = ParameterFlags(0x0) 2 terminals node "a" units = "V", runits = "A" -residual 4294967295 4294967295 4294967295 4294967295 node "c" units = "V", runits = "A" -residual 4294967295 4294967295 4294967295 4294967295 noise "white1" (a, c) noise "white2" (a, c) noise "flickr1" (a, c) noise "flickr2" (a, c) 0 states has bound_step false -instance size 96 -model size 32 diff --git a/openvaf/test_data/osdi/psp102.snap b/openvaf/test_data/osdi/psp102.snap index d8f457c1c..86c84f185 100644 --- a/openvaf/test_data/osdi/psp102.snap +++ b/openvaf/test_data/osdi/psp102.snap @@ -636,78 +636,67 @@ param "XGW" units = "", desc = "", flags = ParameterFlags(0x0) 4 terminals -node "D" units = "V", runits = "" -residual 5088 5096 4294967295 4294967295 -node "G" units = "V", runits = "" -residual 5104 4294967295 4294967295 4294967295 -node "S" units = "V", runits = "" -residual 5112 5120 4294967295 4294967295 -node "B" units = "V", runits = "" -residual 5128 4294967295 4294967295 4294967295 -node "NOI" units = "V", runits = "" -residual 5136 5144 4294967295 4294967295 -node "NOI2" units = "V", runits = "" -residual 5152 4294967295 4294967295 4294967295 -node "GP" units = "V", runits = "" -residual 5160 5168 4294967295 4294967295 -node "BP" units = "V", runits = "" -residual 5176 5184 4294967295 4294967295 -node "BI" units = "V", runits = "" -residual 5192 4294967295 4294967295 4294967295 -node "BS" units = "V", runits = "" -residual 5200 5208 4294967295 4294967295 -node "BD" units = "V", runits = "" -residual 5216 5224 4294967295 4294967295 -jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 408 -jacobian (D, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 416 -jacobian (D, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 424 -jacobian (D, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (D, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 432 -jacobian (D, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 440 -jacobian (D, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 448 -jacobian (D, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456 -jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (S, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464 -jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472 -jacobian (S, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 480 -jacobian (S, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (S, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488 -jacobian (S, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 496 -jacobian (S, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504 -jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (NOI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512 -jacobian (NOI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520 -jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528 -jacobian (NOI, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 536 -jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544 -jacobian (NOI2, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (GP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552 -jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (GP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560 -jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 568 -jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576 -jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 584 -jacobian (BP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (BP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600 -jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BS, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 -jacobian (BD, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640 -jacobian (BD, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648 -jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 +node "D" units = "V", runits = "A" +node "G" units = "V", runits = "A" +node "S" units = "V", runits = "A" +node "B" units = "V", runits = "A" +node "NOI" units = "V", runits = "A" +node "NOI2" units = "V", runits = "A" +node "GP" units = "V", runits = "A" +node "BP" units = "V", runits = "A" +node "BI" units = "V", runits = "A" +node "BS" units = "V", runits = "A" +node "BD" units = "V", runits = "A" +jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (D, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (D, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (D, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (D, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (D, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (D, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (D, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (S, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (S, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (S, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (S, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (S, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (S, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (NOI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI2, NOI2) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (GP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (GP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BS, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) collapsible (G, GP) collapsible (BP, BI) collapsible (BS, BI) @@ -727,5 +716,3 @@ noise "unnamed4" (B, BI) noise "igig" (NOI2, gnd) 0 states has bound_step false -instance size 5760 -model size 2584 diff --git a/openvaf/test_data/osdi/psp103.snap b/openvaf/test_data/osdi/psp103.snap index 5fc3954fe..bac20d683 100644 --- a/openvaf/test_data/osdi/psp103.snap +++ b/openvaf/test_data/osdi/psp103.snap @@ -1692,88 +1692,75 @@ param "FJUNQD" units = "", desc = "Fraction below which drain-bulk junction capacitance components are considered negligible", flags = ParameterFlags(0x0) 4 terminals -node "D" units = "V", runits = "" -residual 6488 4294967295 4294967295 4294967295 -node "G" units = "V", runits = "" -residual 6496 4294967295 4294967295 4294967295 -node "S" units = "V", runits = "" -residual 6504 4294967295 4294967295 4294967295 -node "B" units = "V", runits = "" -residual 6512 4294967295 4294967295 4294967295 -node "NOI" units = "V", runits = "" -residual 6520 6528 4294967295 4294967295 -node "GP" units = "V", runits = "" -residual 6536 6544 4294967295 4294967295 -node "SI" units = "V", runits = "" -residual 6552 6560 4294967295 4294967295 -node "DI" units = "V", runits = "" -residual 6568 6576 4294967295 4294967295 -node "BP" units = "V", runits = "" -residual 6584 6592 4294967295 4294967295 -node "BI" units = "V", runits = "" -residual 6600 4294967295 4294967295 4294967295 -node "BS" units = "V", runits = "" -residual 6608 6616 4294967295 4294967295 -node "BD" units = "V", runits = "" -residual 6624 6632 4294967295 4294967295 -node(flow) "flow(NOII)" units = "A", runits = "" -residual 6640 4294967295 4294967295 4294967295 -jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (D, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (S, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 456 -jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 464 -jacobian (NOI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 472 -jacobian (NOI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 480 -jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 488 -jacobian (NOI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 496 -jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 504 -jacobian (GP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 512 -jacobian (GP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 520 -jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 528 -jacobian (SI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (SI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 536 -jacobian (SI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 544 -jacobian (SI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 552 -jacobian (SI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 560 -jacobian (SI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 568 -jacobian (SI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 576 -jacobian (SI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (DI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (DI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) react_ptr = 584 -jacobian (DI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 592 -jacobian (DI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 600 -jacobian (DI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 608 -jacobian (DI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 616 -jacobian (DI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 624 -jacobian (DI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 632 -jacobian (DI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 640 -jacobian (BP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 648 -jacobian (BP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 656 -jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 664 -jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BS, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 672 -jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 680 -jacobian (BD, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 688 -jacobian (BD, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 696 -jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 704 -jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) react_ptr = 712 -jacobian (flow(NOII), flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "D" units = "V", runits = "A" +node "G" units = "V", runits = "A" +node "S" units = "V", runits = "A" +node "B" units = "V", runits = "A" +node "NOI" units = "V", runits = "A" +node "GP" units = "V", runits = "A" +node "SI" units = "V", runits = "A" +node "DI" units = "V", runits = "A" +node "BP" units = "V", runits = "A" +node "BI" units = "V", runits = "A" +node "BS" units = "V", runits = "A" +node "BD" units = "V", runits = "A" +node(flow) "flow(NOII)" units = "A", runits = "A" +jacobian (D, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (D, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (G, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (G, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (S, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (S, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (B, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (NOI, NOI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (NOI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (GP, G) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (GP, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (GP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (GP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, S) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (SI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (SI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (SI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (DI, D) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (DI, NOI) JacobianFlags(JACOBIAN_ENTRY_REACT | JACOBIAN_ENTRY_RESIST_CONST) +jacobian (DI, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (DI, flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BP, GP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BP, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BP) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BI, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BS, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BS, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BS, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, SI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, DI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, BI) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (BD, BS) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (BD, BD) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT) +jacobian (flow(NOII), flow(NOII)) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_RESIST_CONST | JACOBIAN_ENTRY_REACT_CONST) collapsible (G, GP) collapsible (S, SI) collapsible (D, DI) @@ -1799,5 +1786,3 @@ noise "rwell" (B, BI) noise "igig" (flow(NOII), gnd) 0 states has bound_step false -instance size 7184 -model size 6824 diff --git a/openvaf/test_data/osdi/resistor.snap b/openvaf/test_data/osdi/resistor.snap index 1986b397d..7fa110aa8 100644 --- a/openvaf/test_data/osdi/resistor.snap +++ b/openvaf/test_data/osdi/resistor.snap @@ -8,15 +8,11 @@ param "tnom" units = "Kelvin", desc = "Reference Temp.", flags = ParameterFlags(0x0) 2 terminals -node "A" units = "V", runits = "" -residual 96 4294967295 4294967295 4294967295 -node "B" units = "V", runits = "" -residual 104 4294967295 4294967295 4294967295 -jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (A, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (B, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "A" units = "V", runits = "A" +node "B" units = "V", runits = "A" +jacobian (A, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (A, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (B, A) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (B, B) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 112 -model size 40 diff --git a/openvaf/test_data/osdi/strings.snap b/openvaf/test_data/osdi/strings.snap index 9cdc5928f..da78845d8 100644 --- a/openvaf/test_data/osdi/strings.snap +++ b/openvaf/test_data/osdi/strings.snap @@ -6,11 +6,7 @@ param "dummy2" units = "none", desc = "Dummy", flags = ParameterFlags(PARA_TY_STR) 2 terminals -node "A" units = "V", runits = "" -residual 64 4294967295 4294967295 4294967295 -node "C" units = "V", runits = "" -residual 72 4294967295 4294967295 4294967295 +node "A" units = "V", runits = "A" +node "C" units = "V", runits = "A" 0 states has bound_step false -instance size 80 -model size 32 diff --git a/openvaf/test_data/osdi/vccs.snap b/openvaf/test_data/osdi/vccs.snap index 7851eb07a..c09e98688 100644 --- a/openvaf/test_data/osdi/vccs.snap +++ b/openvaf/test_data/osdi/vccs.snap @@ -8,27 +8,21 @@ param "Rout" units = "Ohm", desc = "output Resistance", flags = ParameterFlags(0x0) 4 terminals -node "Inp" units = "V", runits = "" -residual 192 4294967295 4294967295 4294967295 -node "Inm" units = "V", runits = "" -residual 200 4294967295 4294967295 4294967295 -node "Outp" units = "V", runits = "" -residual 208 4294967295 4294967295 4294967295 -node "Outm" units = "V", runits = "" -residual 216 4294967295 4294967295 4294967295 -jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 -jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) react_ptr = 4294967295 +node "Inp" units = "V", runits = "A" +node "Inm" units = "V", runits = "A" +node "Outp" units = "V", runits = "A" +node "Outm" units = "V", runits = "A" +jacobian (Inp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Inm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outp, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Inp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Inm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Outp) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) +jacobian (Outm, Outm) JacobianFlags(JACOBIAN_ENTRY_RESIST | JACOBIAN_ENTRY_REACT_CONST) 0 states has bound_step false -instance size 224 -model size 40 diff --git a/openvaf/vfs/Cargo.toml b/openvaf/vfs/Cargo.toml index cac615bac..405ad174a 100644 --- a/openvaf/vfs/Cargo.toml +++ b/openvaf/vfs/Cargo.toml @@ -13,7 +13,7 @@ doctest = false paths = {path="../../lib/paths",version="0.0.0"} indexmap = "2.0" -ahash = "0.8" +rustc-hash = "2.0" encoding_rs = "0.8" chardetng = "0.1" diff --git a/openvaf/vfs/src/path_interner.rs b/openvaf/vfs/src/path_interner.rs index 027cd8bf1..c7409e582 100644 --- a/openvaf/vfs/src/path_interner.rs +++ b/openvaf/vfs/src/path_interner.rs @@ -2,14 +2,17 @@ //! no longer exist -- the assumption is total size of paths we ever look at is //! not too big. +use std::hash::BuildHasherDefault; + use indexmap::IndexSet; +use rustc_hash::FxHasher; use crate::{FileId, VfsPath}; /// Structure to map between [`VfsPath`] and [`FileId`]. #[derive(Default, Debug)] pub(crate) struct PathInterner { - map: IndexSet, + map: IndexSet>, } impl PathInterner { diff --git a/rustfmt.toml b/rustfmt.toml index b264203f7..87d4a2723 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -2,5 +2,5 @@ use_small_heuristics = "Max" newline_style = "unix" use_field_init_shorthand = true -imports_granularity = "Module" -group_imports = "StdExternalCrate" +# imports_granularity = "Module" +# group_imports = "StdExternalCrate" diff --git a/sourcegen/src/hir_builtins.rs b/sourcegen/src/hir_builtins.rs index 686f228b7..79e5637bd 100644 --- a/sourcegen/src/hir_builtins.rs +++ b/sourcegen/src/hir_builtins.rs @@ -292,18 +292,20 @@ fn generate_builtins() { } } - pub fn insert_builtin_scope(dst: &mut IndexMap){ + pub fn insert_builtin_scope(dst: &mut IndexMap>){ #(dst.insert(#kw_types::#kws,BuiltIn::#variants.into());)* } - pub fn insert_module_builtin_scope(dst: &mut IndexMap){ + pub fn insert_module_builtin_scope(dst: &mut IndexMap>){ #(dst.insert(sysfun::#params,ParamSysFun::#params.into());)* } }; - let header = "use ahash::RandomState; + let header = "use std::hash::BuildHasherDefault; + use indexmap::IndexMap; + use rustc_hash::FxHasher; use syntax::name::{kw, sysfun, Name}; use crate::nameres::ScopeDefItem; diff --git a/verilogae/verilogae/Cargo.toml b/verilogae/verilogae/Cargo.toml index a15f4ae77..9d549db8d 100644 --- a/verilogae/verilogae/Cargo.toml +++ b/verilogae/verilogae/Cargo.toml @@ -10,6 +10,13 @@ doctest = false crate-type = ["lib", "cdylib"] name = "verilogae" +[features] +# No default - user must specify --features llvm18/llvm19/llvm20/llvm21 +llvm18 = ["dep:llvm-sys-181", "mir_llvm/llvm18"] +llvm19 = ["dep:llvm-sys-191", "mir_llvm/llvm19"] +llvm20 = ["dep:llvm-sys-201", "mir_llvm/llvm20"] +llvm21 = ["dep:llvm-sys-211", "mir_llvm/llvm21"] + [dependencies] syntax = { version = "0.0.0", path = "../../openvaf/syntax" } @@ -18,12 +25,15 @@ hir_lower = { version = "0.0.0", path = "../../openvaf/hir_lower" } hir = { version = "0.0.0", path = "../../openvaf/hir" } mir = { version = "0.0.0", path = "../../openvaf/mir" } -mir_llvm = { version = "0.0.0", path = "../../openvaf/mir_llvm" } +mir_llvm = { version = "0.0.0", path = "../../openvaf/mir_llvm", default-features = false } mir_opt = { version = "0.0.0", path = "../../openvaf/mir_opt" } mir_autodiff = { version = "0.0.0", path = "../../openvaf/mir_autodiff" } #llvm = { version = "0.0.0", path = "../../openvaf/llvm" } -llvm-sys = "181.1.1" +llvm-sys-181 = { package = "llvm-sys", version = "181.2.0", optional = true } +llvm-sys-191 = { package = "llvm-sys", version = "191.0.0", optional = true } +llvm-sys-201 = { package = "llvm-sys", version = "201.0.1", optional = true } +llvm-sys-211 = { package = "llvm-sys", version = "211.0.0", optional = true } target = { version = "0.0.0", path = "../../openvaf/target" } linker = { version = "0.0.0", path = "../../openvaf/linker" } diff --git a/verilogae/verilogae/src/lib.rs b/verilogae/verilogae/src/lib.rs index 1bb8cb254..e47099699 100644 --- a/verilogae/verilogae/src/lib.rs +++ b/verilogae/verilogae/src/lib.rs @@ -1,3 +1,13 @@ +// Re-export the correct llvm-sys version based on feature flags +#[cfg(feature = "llvm18")] +extern crate llvm_sys_181 as llvm_sys; +#[cfg(feature = "llvm19")] +extern crate llvm_sys_191 as llvm_sys; +#[cfg(feature = "llvm20")] +extern crate llvm_sys_201 as llvm_sys; +#[cfg(feature = "llvm21")] +extern crate llvm_sys_211 as llvm_sys; + use std::fs; use std::io::Write; use std::time::Instant; diff --git a/verilogae/verilogae_ffi/Cargo.toml b/verilogae/verilogae_ffi/Cargo.toml index 78bc20c3b..11e00785b 100644 --- a/verilogae/verilogae_ffi/Cargo.toml +++ b/verilogae/verilogae_ffi/Cargo.toml @@ -13,8 +13,13 @@ doctest = false [dependencies] -verilogae = { version = "1.0.0", path = "../verilogae", optional = true } +verilogae = { version = "1.0.0", path = "../verilogae", optional = true, default-features = false } [features] default = ["static"] +# No default LLVM - user must specify --features llvm18/llvm19/llvm20/llvm21 static = ["verilogae"] +llvm18 = ["verilogae?/llvm18"] +llvm19 = ["verilogae?/llvm19"] +llvm20 = ["verilogae?/llvm20"] +llvm21 = ["verilogae?/llvm21"] diff --git a/verilogae/verilogae_py/Cargo.toml b/verilogae/verilogae_py/Cargo.toml index 50b54f409..17d515ed1 100644 --- a/verilogae/verilogae_py/Cargo.toml +++ b/verilogae/verilogae_py/Cargo.toml @@ -26,4 +26,9 @@ pyo3-build-config = { version = "0.19", features = ["resolve-config"] } [features] default = ["static"] +# No default LLVM - user must specify --features llvm18/llvm19/llvm20/llvm21 static = ["verilogae_ffi/static"] +llvm18 = ["verilogae_ffi/llvm18"] +llvm19 = ["verilogae_ffi/llvm19"] +llvm20 = ["verilogae_ffi/llvm20"] +llvm21 = ["verilogae_ffi/llvm21"] diff --git a/xtask/src/flags.rs b/xtask/src/flags.rs index 8ddfe3ad4..5ad8f257c 100644 --- a/xtask/src/flags.rs +++ b/xtask/src/flags.rs @@ -3,6 +3,22 @@ xflags::xflags! { /// Run custom build command. cmd xtask { + /// Build OpenVAF with automatic LLVM detection on macOS + cmd cargo-build { + /// Build in release mode + optional --release + /// Additional arguments to pass to cargo build + repeated args: String + } + + /// Run tests with automatic LLVM detection on macOS + cmd cargo-test { + /// Run tests in release mode + optional --release + /// Additional arguments to pass to cargo test + repeated args: String + } + cmd verilogae{ cmd build{ optional --force @@ -34,10 +50,26 @@ pub struct Xtask { #[derive(Debug)] pub enum XtaskCmd { + CargoBuild(CargoBuild), + CargoTest(CargoTest), Verilogae(Verilogae), GenMsvcrt(GenMsvcrt), } +#[derive(Debug)] +pub struct CargoBuild { + pub args: Vec, + + pub release: bool, +} + +#[derive(Debug)] +pub struct CargoTest { + pub args: Vec, + + pub release: bool, +} + #[derive(Debug)] pub struct Verilogae { pub subcommand: VerilogaeCmd, diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 065ee6803..114b889a7 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -15,7 +15,7 @@ use std::env; use std::path::{Path, PathBuf}; use anyhow::Result; -use xshell::Shell; +use xshell::{cmd, Shell}; // mod cache; mod msvcrt; @@ -26,11 +26,86 @@ fn main() -> Result<()> { let flags = flags::Xtask::from_env()?; match flags.subcommand { + flags::XtaskCmd::CargoBuild(cmd) => cmd.run(&sh), + flags::XtaskCmd::CargoTest(cmd) => cmd.run(&sh), flags::XtaskCmd::Verilogae(cmd) => cmd.run(&mut sh), flags::XtaskCmd::GenMsvcrt(cmd) => cmd.run(&sh), } } +impl flags::CargoBuild { + fn run(&self, sh: &Shell) -> Result<()> { + run_cargo_command(sh, "build", self.release, &self.args) + } +} + +impl flags::CargoTest { + fn run(&self, sh: &Shell) -> Result<()> { + run_cargo_command(sh, "test", self.release, &self.args) + } +} + +fn run_cargo_command( + sh: &Shell, + subcommand: &str, + release: bool, + extra_args: &[String], +) -> Result<()> { + // Auto-detect LLVM on macOS via Homebrew + let llvm_prefix = detect_llvm_prefix(); + + let mut envs: Vec<(&str, String)> = Vec::new(); + + if let Some(prefix) = &llvm_prefix { + eprintln!("Auto-detected LLVM 18 at: {}", prefix); + envs.push(("LLVM_SYS_181_PREFIX", prefix.clone())); + } + + let mut args = Vec::new(); + if release { + args.push("--release".to_string()); + } + args.extend(extra_args.iter().cloned()); + + let mut command = cmd!(sh, "cargo {subcommand} {args...}"); + for (key, value) in envs { + command = command.env(key, value); + } + + command.run()?; + Ok(()) +} + +/// Detect LLVM 18 prefix on macOS via Homebrew. +/// Returns None on non-macOS or if HOMEBREW_PREFIX is not set. +fn detect_llvm_prefix() -> Option { + // Only attempt detection on macOS + if !cfg!(target_os = "macos") { + return None; + } + + // Check if user already set LLVM_SYS_181_PREFIX + if env::var("LLVM_SYS_181_PREFIX").is_ok() { + eprintln!("Using existing LLVM_SYS_181_PREFIX from environment"); + return None; + } + + // Try to get HOMEBREW_PREFIX + let homebrew_prefix = env::var("HOMEBREW_PREFIX").ok()?; + + let llvm_path = format!("{}/opt/llvm@18", homebrew_prefix); + let llvm_bin = format!("{}/bin/llvm-config", llvm_path); + + // Verify LLVM is actually installed there + if Path::new(&llvm_bin).exists() { + Some(llvm_path) + } else { + eprintln!("Note: HOMEBREW_PREFIX is set but llvm@18 not found at {}", llvm_path); + eprintln!("Install with: brew install llvm@18"); + None + } +} + fn project_root() -> PathBuf { Path::new( &env::var("CARGO_MANIFEST_DIR").unwrap_or_else(|_| env!("CARGO_MANIFEST_DIR").to_owned()),