🧠 SemiSimTech Intuition Lab

Co-Simulation Techniques

Build intuition for connecting electrical, photonic, thermal, mechanical, control, and behavioral solvers into one reproducible and trustworthy multi-domain simulation workflow.

Scope

Generic Multi-Domain Co-Simulation

Core Theme

Physics Interfaces + Solver Coupling

Primary Goal

Reproducible and Verifiable Workflows

Technical Support

SemiSimTech Co-Simulation Support

📚 Navigation

1. Big Picture 2. Main Puzzle 3. Coupling Architectures 4. Mathematical View 5. Interface Contract 6. Engineering Workflow 7. Electro-Optic Example 8. Automation Structure 9. Validation 10. Debugging 11. Production Readiness 12. SemiSimTech Support

🧩 Big Picture

Co-simulation is not simply “running two simulators.” It is a controlled exchange of state, excitation, response, and time/frequency information between models that represent different parts of the same physical system.

Domain decomposition Interface physics Solver coupling Verification

Domain decomposition

Each solver owns the physics it handles best. The system is partitioned into domains with clearly defined interface variables.

Information exchange

Outputs from one domain become inputs to another: voltage to optical phase, optical power to photocurrent, temperature to electrical parameters, and so on.

Key intuition: a good co-simulation flow preserves the physical contract at every interface: units, sign convention, reference direction, time base, interpolation method, and valid operating range.

🧠 Main Puzzle

Why can two individually correct solvers still produce a wrong coupled result?

Because correctness inside each solver does not guarantee correctness at the boundary between them. Most multi-domain failures originate from the interface: mismatched units, inconsistent references, unsupported operating ranges, time-grid mismatch, or unstable feedback.

What is the durable engineering skill?

The transferable capability is not a particular simulator. It is the ability to define interfaces, automate execution, control numerical coupling, validate the combined system, and diagnose discrepancies systematically.

🔗 Coupling Architectures

Three architectures cover a large fraction of practical co-simulation problems.

Sequential

Loose / One-Way

Solver A

→

Solver B

Simple and robust. Best when back-coupling is weak or intentionally ignored.

Iterative

Strong / Bidirectional

Solver A

⇄

Solver B

Exchange interface states repeatedly until the coupled solution converges.

Embedded

Tightly Integrated

Master Solver

API

Embedded Model

Provides tight synchronization but requires deeper integration and dependency management.

Engineering tradeoff: tighter coupling can capture more feedback, but usually increases numerical and software complexity.

📐 Mathematical View

Think of each simulator as solving its own residual equation.

F(x, y, t) = 0
G(x, y, t) = 0

The interface problem is to find states x and y that satisfy both domains at the same operating point, wavelength, frequency, or time step.

Fixed-point iteration

x(k+1) = Φ(y(k))
y(k+1) = Ψ(x(k+1))

Easy to implement, but strong feedback can cause oscillation or slow convergence.

Relaxed update

z(k+1) = (1 - α) z(k) + α z*

For 0 < α ≤ 1, smaller α damps iteration oscillation at the cost of slower convergence.

Important: convergence of every individual solver does not guarantee convergence of the coupled system. The interface residual must be monitored explicitly.

🧾 Interface Contract

Define the interface before writing automation.

Physical definition

Quantity: voltage, current, temperature, optical power, phase, displacement, pressure, etc.
Units: V vs mV, W vs dBm, K vs °C, Hz vs rad/s.
Reference and direction: positive current direction, optical reference plane, thermal reference.

Numerical definition

Independent variable: time, frequency, wavelength, bias, temperature, geometry.
Sampling: uniform, adaptive, or irregular.
Interpolation: linear, spline, rational fit, zero-order hold.
Validity range and extrapolation behavior.

Rule: every interface variable should have an explicit name, unit, sign convention, reference, sampling definition, interpolation policy, and allowed range.

🛠️ Engineering Workflow

A reusable five-stage co-simulation flow.

Define

Physics, ports, units, references.

Characterize

Generate compact or sampled response data.

Couple

Map variables between domains.

Solve

Orchestrate iterations or time steps.

Verify

Correlation, conservation, and limits.

Software layers

Environment layer: executable locations, versions, runtime variables.
Job layer: launch tools and collect outputs.
Adapter layer: translate formats, units, ports, and naming.

Physics-aware layers

Coupling layer: synchronization, relaxation, convergence.
Verification layer: regression, correlation, physical invariants.

💡 Generic Electro-Optic Example

Forward path

Electrical solver produces node voltage or current.
An interface model converts electrical state to refractive-index or absorption change.
Photonic solver calculates transmission, phase, power, or scattering response.
System-level outputs are evaluated against specifications.

Possible feedback path

Optical absorption generates heat.
Temperature shifts electrical or optical properties.
Photodetection can generate electrical current.
The coupled solution repeats until mutually consistent.

Intuition: the coupling object is often more important than the simulator brand. A validated interface can survive a tool change; a poorly defined one usually cannot.

💻 Automation Structure

Graphical setup is excellent for exploration. Reproducible engineering benefits from command-line execution, scripted configuration, machine-readable results, and deterministic regression.

project/
├── config/
│ ├── coupling.yaml
│ └── environment.yaml
├── models/
│ ├── electrical/
│ ├── optical/
│ └── thermal/
├── adapters/
│ ├── electrical_to_optical.py
│ └── optical_to_thermal.py
├── runs/
├── validation/
│ ├── golden_cases/
│ └── tolerances.yaml
└── run_cosim.py

Best practice: keep solver-specific commands inside adapters. The top-level orchestration layer should operate on physical concepts rather than tool-specific syntax.

✅ Validation

A coupled workflow should prove more than “the simulation completed.”

Unit Tests

Interface correctness

Test every unit conversion, interpolation routine, sign convention, and parser independently.

Baselines

Single-domain trust

Each solver should match a known reference before coupling is enabled.

Invariants

Physical consistency

Check conservation, limiting behavior, symmetry, monotonic trends, and known asymptotes.

Recommended minimum: zero-coupling limit, small-signal limit, grid/timestep refinement, power or energy balance, and explicit extrapolation detection.

🧯 Debugging Guide

Environment / executable mismatch

Record tool versions, shared-library dependencies, runtime variables, and an environment fingerprint with every run.

Port or terminal mismatch

Validate interface names, ordering, direction, polarity, and reference nodes.

Unit mismatch

A smooth result can still be wrong by 10³ or 10⁹. Use dimensional checks at every boundary.

Time-grid mismatch

Adaptive solvers rarely evaluate at identical time points. Define synchronization and interpolation explicitly.

Strong feedback oscillation

Use relaxation, better initialization, tighter coupling, or a different numerical strategy.

Hidden extrapolation

Detect when lookup tables or reduced-order models are queried outside their calibrated range.

🚦 Production-Readiness Checklist

Interface variables and units are documented.
Tool versions and runtime dependencies are captured.
Single-domain reference cases pass.
Coupled convergence criteria are explicit.

Out-of-range model usage is detected.
Regression cases execute automatically.
Results contain configuration and provenance metadata.
A failed case can be reproduced from a clean environment.

🧭 SemiSimTech Technical Support

SemiSimTech supports the engineering methodology around multi-domain simulation: architecture, model interfaces, automation, convergence, verification, and systematic debugging.

Technical scope

Co-simulation architecture and domain partitioning
Electrical / photonic / thermal interface design
Compact-model and lookup-table integration
CLI and Python-based orchestration

Verification scope

Solver synchronization and convergence strategy
Automated regression frameworks
Correlation and discrepancy debugging
Reusable project structures and documentation

🚀 Final Insight

SemiSimTech principle: treat co-simulation as a verified software-and-physics workflow, not as an ad hoc connection between tools.

This Intuition Lab intentionally contains no foundry-specific process information, proprietary PDK details, customer information, or confidential workflows.