From 2da5b1e241d5fb736529a8bb82daebad0a56a233 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Damiano=20Franz=C3=B2?= Date: Wed, 15 Oct 2025 14:08:14 +0200 Subject: [PATCH 1/2] feat: Add SSAC notebook --- ssac_introductory_notebook.ipynb | 916 +++++++++++++++++++++++++++++++ 1 file changed, 916 insertions(+) create mode 100644 ssac_introductory_notebook.ipynb diff --git a/ssac_introductory_notebook.ipynb b/ssac_introductory_notebook.ipynb new file mode 100644 index 00000000..c7612133 --- /dev/null +++ b/ssac_introductory_notebook.ipynb @@ -0,0 +1,916 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Small-Signal AC Analysis of a Silicon PIN Photodiode\n", + "\n", + "## Introduction to Small-Signal Analysis\n", + "\n", + "Small-Signal AC (SSAC) analysis is a technique used to characterize the frequency-dependent behavior of semiconductor devices under small perturbations around a DC operating point. This method is essential for understanding the high-frequency performance limitations of devices such as photodiodes, modulators, and transistors.\n", + "\n", + "### What is Small-Signal Analysis?\n", + "\n", + "In SSAC analysis, we first establish a DC operating point (bias condition) for the device. Then, we apply a small AC voltage perturbation and analyze how the device responds at different frequencies. The analysis assumes that the perturbation is small enough that the device's response remains linear, allowing us to extract frequency-dependent parameters.\n", + "\n", + "### Key Output Parameters\n", + "\n", + "The primary output of SSAC analysis is the **small-signal admittance** $ Y(\\omega) $, which relates the small-signal current $ I(\\omega) $ to the small-signal voltage $ V(\\omega) $:\n", + "\n", + "$$\n", + "Y(\\omega) = \\frac{I(\\omega)}{V(\\omega)} = G(\\omega) + j\\omega C(\\omega)\n", + "$$\n", + "\n", + "where:\n", + "- $ G(\\omega) $ is the **conductance** (real part of admittance), representing resistive losses\n", + "- $ C(\\omega) $ is the **capacitance** (imaginary part divided by $ \\omega )$, representing charge storage\n", + "- $ \\omega = 2\\pi f $ is the angular frequency\n", + "\n", + "### Goal of This Notebook\n", + "\n", + "In this tutorial, we will:\n", + "1. Set up a reverse-biased silicon PIN photodiode structure\n", + "2. Perform SSAC analysis over a range of frequencies\n", + "3. Extract and plot the frequency-dependent conductance $ G(f) $ and capacitance $ C(f) $" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup and Imports\n" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import tidy3d as td\n", + "\n", + "#TODO REMOVE\n", + "from tidy3d_backend.run_heat import run_heat_sim" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Device and Simulation Setup\n", + "\n", + "### PIN Photodiode Structure\n", + "\n", + "We will design a vertical PIN photodiode with the following structure:\n", + "- **P+ region**: Heavily doped p-type silicon (top contact)\n", + "- **Intrinsic region**: Lightly doped silicon (absorption region)\n", + "- **N+ region**: Heavily doped n-type silicon (bottom contact)\n", + "- **Metal contacts**: Aluminum electrodes for electrical connection\n", + "\n", + "The device will be operated under reverse bias (negative voltage on p-side), which depletes the intrinsic region and creates a strong electric field for efficient photocarrier collection.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Geometry Definition\n", + "\n", + "First, we define the geometric parameters of our PIN structure. All dimensions are in micrometers (µm).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "# Device dimensions (µm)\n", + "device_width = 2.0 # Lateral dimension\n", + "z_size = 2.0 # Extrusion dimension (for 2D simulation)\n", + "\n", + "# Layer thicknesses\n", + "p_thickness = 0.3 # P+ contact layer\n", + "i_thickness = 1.0 # Intrinsic absorption region\n", + "n_thickness = 0.3 # N+ contact layer\n", + "contact_thickness = 0.2 # Metal contact thickness\n", + "\n", + "# Layer centers (stacked vertically along y-axis)\n", + "total_height = p_thickness + i_thickness + n_thickness\n", + "y_bottom = -total_height / 2\n", + "\n", + "# N+ layer (bottom)\n", + "n_center_y = y_bottom + n_thickness / 2\n", + "n_center = (0, n_center_y, 0)\n", + "n_size = (device_width, n_thickness, z_size)\n", + "\n", + "# Intrinsic layer (middle)\n", + "i_center_y = n_center_y + n_thickness / 2 + i_thickness / 2\n", + "i_center = (0, i_center_y, 0)\n", + "i_size = (device_width, i_thickness, z_size)\n", + "\n", + "# P+ layer (top)\n", + "p_center_y = i_center_y + i_thickness / 2 + p_thickness / 2\n", + "p_center = (0, p_center_y, 0)\n", + "p_size = (device_width, p_thickness, z_size)\n", + "\n", + "# Contact layers\n", + "contact_n_y = n_center_y - n_thickness / 2 - contact_thickness / 2\n", + "contact_p_y = p_center_y + p_thickness / 2 + contact_thickness / 2\n", + "\n", + "contact_n_center = (0, contact_n_y, 0)\n", + "contact_p_center = (0, contact_p_y, 0)\n", + "contact_size = (device_width, contact_thickness, z_size)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Doping Profile\n", + "\n", + "Next, we define the doping profiles for the PIN structure. We use:\n", + "- **Constant doping** for the lightly doped intrinsic region (background doping)\n", + "- **Gaussian doping** for the heavily doped P+ and N+ regions with smooth transitions\n", + "\n", + "The doping concentrations are based on typical values for silicon photodiodes.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "# Doping concentrations (cm^-3)\n", + "intrinsic_doping = 1e14 # Background doping in intrinsic region\n", + "p_plus_doping = 1e19 # P+ contact doping\n", + "n_plus_doping = 1e19 # N+ contact doping\n", + "\n", + "# Junction width for Gaussian doping profiles\n", + "junction_width = 0.05 # Controls sharpness of doping transition\n", + "\n", + "# Intrinsic region: constant low doping\n", + "acceptor_intrinsic = td.ConstantDoping(\n", + " center=i_center,\n", + " size=i_size,\n", + " concentration=intrinsic_doping\n", + ")\n", + "\n", + "# P+ region: Gaussian acceptor doping\n", + "acceptor_p_plus = td.GaussianDoping(\n", + " center=p_center,\n", + " size=p_size,\n", + " concentration=p_plus_doping,\n", + " ref_con=intrinsic_doping,\n", + " width=junction_width,\n", + " source=\"ymax\" # Doping is constant along ymax plane\n", + ")\n", + "\n", + "# N+ region: Gaussian donor doping\n", + "donor_n_plus = td.GaussianDoping(\n", + " center=n_center,\n", + " size=n_size,\n", + " concentration=n_plus_doping,\n", + " ref_con=intrinsic_doping,\n", + " width=junction_width,\n", + " source=\"ymin\" # Doping is constant along ymin plane\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Material Models\n", + "\n", + "We now define the physical models for silicon. The parameters are based on well-established models from semiconductor device physics literature." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Electron mobility model (Caughey-Thomas)\n", + "mobility_n = td.CaugheyThomasMobility(\n", + " mu=1471.0, # Maximum mobility (cm²/V·s)\n", + " mu_min=52.2, # Minimum mobility (cm²/V·s)\n", + " ref_N=9.68e16, # Reference doping (cm⁻³)\n", + " exp_N=0.68, # Doping exponent\n", + " exp_1=-0.57, # Temperature exponent 1\n", + " exp_2=-2.33, # Temperature exponent 2\n", + " exp_3=2.4, # Temperature exponent 3\n", + " exp_4=-0.146 # Temperature exponent 4\n", + ")\n", + "\n", + "# Hole mobility model (Caughey-Thomas)\n", + "mobility_p = td.CaugheyThomasMobility(\n", + " mu=470.5, # Maximum mobility (cm²/V·s)\n", + " mu_min=44.9, # Minimum mobility (cm²/V·s)\n", + " ref_N=2.23e17, # Reference doping (cm⁻³)\n", + " exp_N=0.719, # Doping exponent\n", + " exp_1=-0.57, # Temperature exponent 1\n", + " exp_2=-2.23, # Temperature exponent 2\n", + " exp_3=2.4, # Temperature exponent 3\n", + " exp_4=-0.146 # Temperature exponent 4\n", + ")\n", + "\n", + "# Effective density of states (constant for isothermal simulation)\n", + "# Values at T=300K from Sze & Ng\n", + "N_c = td.ConstantEffectiveDOS(N=2.86e19) # Conduction band (cm⁻³)\n", + "N_v = td.ConstantEffectiveDOS(N=3.1e19) # Valence band (cm⁻³)\n", + "\n", + "# Energy bandgap at 300K\n", + "E_g = td.ConstantEnergyBandGap(eg=1.12) # Silicon bandgap (eV)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Recombination Models\n", + "\n", + "We include the major recombination mechanisms in silicon:\n", + "- **Shockley-Read-Hall (SRH)**: Recombination through trap states\n", + "- **Radiative**: Band-to-band recombination (weak in silicon)\n", + "- **Auger**: Three-particle recombination (important at high carrier densities)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [], + "source": [ + "# Shockley-Read-Hall recombination\n", + "# Carrier lifetimes for moderately pure silicon\n", + "srh_recombination = td.ShockleyReedHallRecombination(\n", + " tau_n=1e-6, # Electron lifetime (s)\n", + " tau_p=1e-6 # Hole lifetime (s)\n", + ")\n", + "\n", + "# Radiative recombination (weak in indirect-gap silicon)\n", + "radiative_recombination = td.RadiativeRecombination(\n", + " r_const=1.6e-14 # Radiative recombination coefficient (cm³/s)\n", + ")\n", + "\n", + "# Auger recombination (important at high doping)\n", + "auger_recombination = td.AugerRecombination(\n", + " c_n=2.8e-31, # Electron Auger coefficient (cm⁶/s)\n", + " c_p=9.9e-32 # Hole Auger coefficient (cm⁶/s)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Bandgap Narrowing\n", + "\n", + "At high doping levels, carrier-carrier interactions cause the effective bandgap to shrink. We use the **Slotboom model** to account for this effect.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Bandgap narrowing model (Slotboom)\n", + "bandgap_narrowing = td.SlotboomBandGapNarrowing(\n", + " v1=6.92e-3, # Narrowing coefficient (eV)\n", + " n2=1.3e17, # Reference concentration (cm⁻³)\n", + " c2=0.5, # Exponent\n", + " min_N=1e15 # Minimum doping for narrowing (cm⁻³)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create MultiPhysics Media\n", + "\n", + "We now assemble all the material properties into `MultiPhysicsMedium` objects for use in the simulation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "# Silicon semiconductor medium with all doping and physical models\n", + "si_charge = td.SemiconductorMedium(\n", + " permittivity=11.7,\n", + " N_c=N_c,\n", + " N_v=N_v,\n", + " E_g=E_g,\n", + " N_d=[donor_n_plus], # List of donor doping profiles\n", + " N_a=[acceptor_intrinsic, acceptor_p_plus], # List of acceptor doping profiles\n", + " mobility_n=mobility_n,\n", + " mobility_p=mobility_p,\n", + " R=[srh_recombination, radiative_recombination, auger_recombination],\n", + " delta_E_g=bandgap_narrowing\n", + ")\n", + "\n", + "# Silicon as a MultiPhysicsMedium\n", + "Si_medium = td.MultiPhysicsMedium(\n", + " charge=si_charge,\n", + " name=\"Si_doped\"\n", + ")\n", + "\n", + "# Aluminum contacts (high conductivity metal)\n", + "Al_medium = td.MultiPhysicsMedium(\n", + " charge=td.ChargeConductorMedium(conductivity=3.5e7 * 1e-6), # Convert to µm units\n", + " name=\"Al\"\n", + ")\n", + "\n", + "# Air as background medium\n", + "air = td.MultiPhysicsMedium(\n", + " name=\"air\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create Geometry Structures\n" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "# Silicon structures\n", + "si_p_structure = td.Structure(\n", + " geometry=td.Box(center=p_center, size=p_size),\n", + " medium=Si_medium,\n", + " name=\"si_p_region\"\n", + ")\n", + "\n", + "si_i_structure = td.Structure(\n", + " geometry=td.Box(center=i_center, size=i_size),\n", + " medium=Si_medium,\n", + " name=\"si_i_region\"\n", + ")\n", + "\n", + "si_n_structure = td.Structure(\n", + " geometry=td.Box(center=n_center, size=n_size),\n", + " medium=Si_medium,\n", + " name=\"si_n_region\"\n", + ")\n", + "\n", + "# Metal contact structures\n", + "contact_p_structure = td.Structure(\n", + " geometry=td.Box(center=contact_p_center, size=contact_size),\n", + " medium=Al_medium,\n", + " name=\"contact_p\"\n", + ")\n", + "\n", + "contact_n_structure = td.Structure(\n", + " geometry=td.Box(center=contact_n_center, size=contact_size),\n", + " medium=Al_medium,\n", + " name=\"contact_n\"\n", + ")\n", + "\n", + "# Combine all structures\n", + "structures = [\n", + " si_n_structure,\n", + " si_i_structure,\n", + " si_p_structure,\n", + " contact_n_structure,\n", + " contact_p_structure\n", + "]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the Device Structure\n", + "\n", + "Before running the simulation, let's visualize the device geometry and doping profile.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create scene for visualization\n", + "scene = td.Scene(structures=structures, medium=air)\n", + "\n", + "# Plot geometry and doping\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "# Plot structure geometry\n", + "scene.plot(z=0, ax=ax1)\n", + "ax1.set_title(\"PIN Photodiode Cross-Section\")\n", + "ax1.set_xlabel(\"x (µm)\")\n", + "ax1.set_ylabel(\"y (µm)\")\n", + "\n", + "# Plot doping profile\n", + "scene.plot_structures_property(z=0, property=\"doping\", ax=ax2, scale=\"symlog\")\n", + "ax2.set_title(\"Net Doping Concentration (cm⁻³)\")\n", + "ax2.set_xlabel(\"x (µm)\")\n", + "ax2.set_ylabel(\"y (µm)\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Boundary Conditions and SSAC Setup\n", + "\n", + "Now we define the electrical boundary conditions for the SSAC analysis:\n", + "\n", + "1. **Cathode (N-contact)**: Grounded at 0V\n", + "2. **Anode (P-contact)**: SSAC voltage source with DC bias and small-signal perturbation\n", + "\n", + "For a typical photodiode, we apply a **reverse bias** (negative voltage on p-side) to:\n", + "- Deplete the intrinsic region\n", + "- Create a strong electric field for fast carrier collection\n", + "- Reduce dark current\n", + "- Minimize junction capacitance\n" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "# DC bias voltages for reverse bias operation\n", + "reverse_bias_voltages = [-2] # -2V reverse bias\n", + "\n", + "# Small-signal amplitude (must be small for linear approximation)\n", + "ac_amplitude = 1e-3 # 1 mV perturbation\n", + "\n", + "# Cathode: ground reference (N-contact)\n", + "bc_cathode = td.HeatChargeBoundarySpec(\n", + " condition=td.VoltageBC(source=td.GroundVoltage()),\n", + " placement=td.StructureStructureInterface(\n", + " structures=[\"contact_n\", \"si_n_region\"]\n", + " )\n", + ")\n", + "\n", + "# Anode: SSAC voltage source (P-contact)\n", + "bc_anode = td.HeatChargeBoundarySpec(\n", + " condition=td.VoltageBC(\n", + " source=td.SSACVoltageSource(\n", + " voltage=reverse_bias_voltages,\n", + " amplitude=ac_amplitude\n", + " )\n", + " ),\n", + " placement=td.StructureStructureInterface(\n", + " structures=[\"contact_p\", \"si_p_region\"]\n", + " )\n", + ")\n", + "\n", + "boundary_specs = [bc_cathode, bc_anode]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Frequency Range for SSAC Analysis\n", + "\n", + "We define a logarithmic frequency sweep from 100 Mhz to 100 GHz to capture the frequency-dependent behavior.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "# Frequency range for SSAC analysis (Hz)\n", + "freq_min = 1e8 # 100 Mhz\n", + "freq_max = 1e11 # 100 GHz\n", + "n_freqs_per_decade = 5 # Number of frequency points per decade\n", + "\n", + "freq_range = td.FreqRange.from_freq_interval(freq_min, freq_max)\n", + "freqs = freq_range.sweep_decade(n_freqs_per_decade)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define Monitors\n", + "\n", + "We set up monitors to record various quantities during the simulation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "# Monitor for free carrier concentration\n", + "carrier_monitor = td.SteadyFreeCarrierMonitor(\n", + " center=(0, 0, 0),\n", + " size=(td.inf, td.inf, td.inf),\n", + " name=\"carriers\",\n", + " unstructured=True\n", + ")\n", + "\n", + "# Monitor for electric potential\n", + "potential_monitor = td.SteadyPotentialMonitor(\n", + " center=(0, 0, 0),\n", + " size=(td.inf, td.inf, td.inf),\n", + " name=\"potential\",\n", + " unstructured=True\n", + ")\n", + "\n", + "monitors = [carrier_monitor, potential_monitor]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Analysis and Solver Settings\n", + "\n", + "We configure the SSAC analysis parameters and solver tolerance settings.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "# Solver tolerance settings\n", + "charge_tolerance = td.ChargeToleranceSpec(\n", + " rel_tol=1e-5, # Relative tolerance\n", + " abs_tol=1e16, # Absolute tolerance (cm⁻³)\n", + " max_iters=400, # Maximum iterations\n", + " ramp_up_iters=1 # Ramping iterations for convergence\n", + ")\n", + "\n", + "# SSAC analysis specification\n", + "analysis_spec = td.IsothermalSSACAnalysis(\n", + " tolerance_settings=charge_tolerance,\n", + " convergence_dv=0.1, # Voltage convergence criterion (V)\n", + " fermi_dirac=False, # Use Maxwell-Boltzmann statistics (faster, adequate for moderate doping)\n", + " temperature=300, # Ambient temperature (K)\n", + " freqs=freqs.tolist() # Frequency list for AC analysis\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Grid Specification\n", + "\n", + "We define the mesh for the simulation. A finer mesh near the junctions ensures accurate resolution of the space-charge regions where the electric field varies rapidly.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "# Base mesh resolution\n", + "dl_bulk = 0.04 # Bulk mesh size (µm)\n", + "dl_interface = 0.015 # Interface mesh size (µm)\n", + "\n", + "# Refined regions near P-I and I-N junctions\n", + "refinement_pi = td.GridRefinementRegion(\n", + " center=(0, p_center_y - p_thickness/2, 0),\n", + " size=(device_width, 0.2, 0),\n", + " dl_internal=dl_interface / 2,\n", + " transition_thickness=dl_bulk * 10\n", + ")\n", + "\n", + "refinement_in = td.GridRefinementRegion(\n", + " center=(0, n_center_y + n_thickness/2, 0),\n", + " size=(device_width, 0.2, 0),\n", + " dl_internal=dl_interface / 2,\n", + " transition_thickness=dl_bulk * 10\n", + ")\n", + "\n", + "# Grid specification\n", + "grid_spec = td.DistanceUnstructuredGrid(\n", + " relative_min_dl=0,\n", + " dl_interface=dl_interface,\n", + " dl_bulk=dl_bulk * 20,\n", + " distance_interface=2 * dl_interface,\n", + " distance_bulk=6 * dl_interface,\n", + " sampling=1000,\n", + " uniform_grid_mediums=[\"Si_doped\"],\n", + " mesh_refinements=[refinement_pi, refinement_in]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create the Simulation\n", + "\n", + "Finally, we assemble all components into a `HeatChargeSimulation` object.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "# Simulation domain\n", + "sim_center = (0, 0, 0)\n", + "sim_size = (device_width * 0.8, total_height + 2 * contact_thickness + 0.2, 0)\n", + "\n", + "# Create simulation\n", + "sim = td.HeatChargeSimulation(\n", + " medium=air,\n", + " structures=structures,\n", + " size=sim_size,\n", + " center=sim_center,\n", + " boundary_spec=boundary_specs,\n", + " analysis_spec=analysis_spec,\n", + " monitors=monitors,\n", + " grid_spec=grid_spec\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the Simulation\n", + "\n", + "Now we run the SSAC simulation using the Tidy3D backend solver. The simulation will first solve the DC problem at the specified bias voltage. Then, it will perform small-signal analysis at each frequency and extract AC current response." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# TOREMOVE - Run simulation (backend mode)\n", + "# In the final version, this will use web.run() for web submission\n", + "results = run_heat_sim(sim=sim, log_level=\"INFO\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Post-Processing and Results Analysis\n", + "\n", + "### Extract AC Current Data\n", + "\n", + "The SSAC simulation provides complex-valued AC current $I(v, f)$ as a function of DC bias voltage $v$ and frequency $f$ . This current represents the device's small-signal response to the AC voltage perturbation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract AC current-voltage data\n", + "ac_current = -results.device_characteristics.ac_current_voltage\n", + "\n", + "# Get the bias voltage and frequency arrays\n", + "bias_voltage = reverse_bias_voltages[0]\n", + "frequencies = ac_current.coords['f'].values # Frequency array\n", + "\n", + "# Select current at the specified bias voltage\n", + "# Note: For 2D simulations, multiply by device depth to get total current\n", + "device_depth = 50 # µm (assuming device extends 50 µm in z-direction)\n", + "I_ac = ac_current.sel(v=bias_voltage).values * device_depth\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(12, 5))\n", + "# Plot conductance\n", + "ax.loglog(frequencies / 1e6, I_ac.real, 'o-', linewidth=2, markersize=6, label='Real(I)')\n", + "ax.loglog(frequencies / 1e6, I_ac.imag, '*-', linewidth=2, markersize=6, label='Imag(I)')\n", + "ax.set_xlabel('Frequency (MHz)', fontsize=12)\n", + "ax.set_ylabel('Current (A)', fontsize=12)\n", + "ax.set_title('Current plot', fontsize=13, fontweight='bold')\n", + "ax.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax.legend(fontsize=11)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate Admittance, Conductance, and Capacitance\n", + "\n", + "From the AC current $I(\\omega)$ and the applied AC voltage amplitude $V_0$ , we calculate:\n", + "\n", + "1. **Admittance**: $Y(\\omega)$ = $\\frac{I(\\omega)}{V_0} $\n", + "\n", + "2. **Conductance**: $G(\\omega)$ = $\\text{Re}[Y(\\omega)]$ — represents resistive losses\n", + "\n", + "3. **Capacitance**: $C(\\omega)$ = $\\frac{\\text{Im}[Y(\\omega)]}{\\omega}$ — represents charge storage\n", + "\n", + "where $\\omega = 2\\pi f$ is the angular frequency.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [], + "source": [ + "# Calculate admittance Y = I / V\n", + "Y = I_ac / ac_amplitude # Admittance (S)\n", + "\n", + "# Extract real and imaginary parts\n", + "G = np.real(Y) # Conductance (S)\n", + "B = np.imag(Y) # Susceptance (S)\n", + "\n", + "# Calculate capacitance from susceptance: C = B / ω = B / (2πf)\n", + "omega = 2 * np.pi * frequencies # Angular frequency (rad/s)\n", + "C = B / omega # Capacitance (F)\n", + "\n", + "# Convert to more convenient units\n", + "C_pF = C * 1e12 # Capacitance in pF\n", + "G_uS = G * 1e6 # Conductance in µS" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plot Frequency-Dependent Conductance\n", + "\n", + "Let's create a combined plot showing both conductance $G(f)$ and capacitance $C(f)$ to visualize the complete admittance behavior." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 6))\n", + "\n", + "# Plot conductance\n", + "ax1.loglog(frequencies / 1e6, G_uS, 'o-', linewidth=2, markersize=6, color='#2E86AB', label='Conductance G')\n", + "ax1.set_xlabel('Frequency (MHz)', fontsize=12)\n", + "ax1.set_ylabel('Conductance (µS)', fontsize=12)\n", + "ax1.set_title('Real Part of Admittance: Conductance', fontsize=13, fontweight='bold')\n", + "ax1.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax1.legend(fontsize=11)\n", + "\n", + "# Plot capacitance\n", + "ax2.loglog(frequencies / 1e6, C_pF, 'o-', linewidth=2, markersize=6, color='#A23B72', label='Capacitance C')\n", + "ax2.set_xlabel('Frequency (MHz)', fontsize=12)\n", + "ax2.set_ylabel('Capacitance (pF)', fontsize=12)\n", + "ax2.set_title('Imaginary Part of Admittance: Capacitance', fontsize=13, fontweight='bold')\n", + "ax2.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax2.legend(fontsize=11)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Physical Interpretation of Results\n", + "The capacitance $C(f)$ we observe is primarily the **junction capacitance** of the reverse-biased PIN diode. Under reverse bias, the intrinsic region is fully depleted, and W is approximately equal to the intrinsic layer thickness." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize DC Solution\n", + "\n", + "Before concluding, we visualize the potential distrution at the DC operating point.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Extract potential at the bias voltage\n", + "potential = results[\"potential\"].potential.sel(voltage=bias_voltage, z=0, method='nearest')\n", + "\n", + "# Create figure with subplots\n", + "fig, ax = plt.subplots(1, 1, figsize=(10, 6))\n", + "\n", + "# Plot potential\n", + "potential.plot(ax=ax, cmap='viridis', grid=False)\n", + "ax.set_title(f'Electric Potential at {bias_voltage:.1f}V', fontsize=12, fontweight='bold')\n", + "ax.set_xlabel('x (µm)')\n", + "ax.set_ylabel('y (µm)')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "In this tutorial, we have successfully:\n", + "\n", + "1. **Desigend a silicon PIN photodiode** with realistic doping profiles and material parameters\n", + "2. **Set up and performed Small-Signal AC (SSAC) analysis** using Tidy3D's small-signal analysis framework.\n", + "3. **Extracted frequency-dependent device parameters** including conductance $G(f)$ and capacitance $C(f)$. \n", + "4. **Analyzed the results** in the context of photodiode physics and performance." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 137f3f2d84602419a1eafb6a389d774f0fc9d2a8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Damiano=20Franz=C3=B2?= Date: Wed, 15 Oct 2025 14:12:56 +0200 Subject: [PATCH 2/2] Fix ruff format --- ssac_introductory_notebook.ipynb | 228 ++++++++++++++----------------- 1 file changed, 100 insertions(+), 128 deletions(-) diff --git a/ssac_introductory_notebook.ipynb b/ssac_introductory_notebook.ipynb index c7612133..8db1a427 100644 --- a/ssac_introductory_notebook.ipynb +++ b/ssac_introductory_notebook.ipynb @@ -52,7 +52,7 @@ "import matplotlib.pyplot as plt\n", "import tidy3d as td\n", "\n", - "#TODO REMOVE\n", + "# TODO REMOVE\n", "from tidy3d_backend.run_heat import run_heat_sim" ] }, @@ -89,13 +89,13 @@ "outputs": [], "source": [ "# Device dimensions (µm)\n", - "device_width = 2.0 # Lateral dimension\n", - "z_size = 2.0 # Extrusion dimension (for 2D simulation)\n", + "device_width = 2.0 # Lateral dimension\n", + "z_size = 2.0 # Extrusion dimension (for 2D simulation)\n", "\n", "# Layer thicknesses\n", - "p_thickness = 0.3 # P+ contact layer\n", - "i_thickness = 1.0 # Intrinsic absorption region\n", - "n_thickness = 0.3 # N+ contact layer\n", + "p_thickness = 0.3 # P+ contact layer\n", + "i_thickness = 1.0 # Intrinsic absorption region\n", + "n_thickness = 0.3 # N+ contact layer\n", "contact_thickness = 0.2 # Metal contact thickness\n", "\n", "# Layer centers (stacked vertically along y-axis)\n", @@ -123,7 +123,7 @@ "\n", "contact_n_center = (0, contact_n_y, 0)\n", "contact_p_center = (0, contact_p_y, 0)\n", - "contact_size = (device_width, contact_thickness, z_size)\n" + "contact_size = (device_width, contact_thickness, z_size)" ] }, { @@ -146,19 +146,15 @@ "outputs": [], "source": [ "# Doping concentrations (cm^-3)\n", - "intrinsic_doping = 1e14 # Background doping in intrinsic region\n", - "p_plus_doping = 1e19 # P+ contact doping\n", - "n_plus_doping = 1e19 # N+ contact doping\n", + "intrinsic_doping = 1e14 # Background doping in intrinsic region\n", + "p_plus_doping = 1e19 # P+ contact doping\n", + "n_plus_doping = 1e19 # N+ contact doping\n", "\n", "# Junction width for Gaussian doping profiles\n", - "junction_width = 0.05 # Controls sharpness of doping transition\n", + "junction_width = 0.05 # Controls sharpness of doping transition\n", "\n", "# Intrinsic region: constant low doping\n", - "acceptor_intrinsic = td.ConstantDoping(\n", - " center=i_center,\n", - " size=i_size,\n", - " concentration=intrinsic_doping\n", - ")\n", + "acceptor_intrinsic = td.ConstantDoping(center=i_center, size=i_size, concentration=intrinsic_doping)\n", "\n", "# P+ region: Gaussian acceptor doping\n", "acceptor_p_plus = td.GaussianDoping(\n", @@ -167,7 +163,7 @@ " concentration=p_plus_doping,\n", " ref_con=intrinsic_doping,\n", " width=junction_width,\n", - " source=\"ymax\" # Doping is constant along ymax plane\n", + " source=\"ymax\", # Doping is constant along ymax plane\n", ")\n", "\n", "# N+ region: Gaussian donor doping\n", @@ -177,7 +173,7 @@ " concentration=n_plus_doping,\n", " ref_con=intrinsic_doping,\n", " width=junction_width,\n", - " source=\"ymin\" # Doping is constant along ymin plane\n", + " source=\"ymin\", # Doping is constant along ymin plane\n", ")" ] }, @@ -198,35 +194,35 @@ "source": [ "# Electron mobility model (Caughey-Thomas)\n", "mobility_n = td.CaugheyThomasMobility(\n", - " mu=1471.0, # Maximum mobility (cm²/V·s)\n", - " mu_min=52.2, # Minimum mobility (cm²/V·s)\n", - " ref_N=9.68e16, # Reference doping (cm⁻³)\n", - " exp_N=0.68, # Doping exponent\n", - " exp_1=-0.57, # Temperature exponent 1\n", - " exp_2=-2.33, # Temperature exponent 2\n", - " exp_3=2.4, # Temperature exponent 3\n", - " exp_4=-0.146 # Temperature exponent 4\n", + " mu=1471.0, # Maximum mobility (cm²/V·s)\n", + " mu_min=52.2, # Minimum mobility (cm²/V·s)\n", + " ref_N=9.68e16, # Reference doping (cm⁻³)\n", + " exp_N=0.68, # Doping exponent\n", + " exp_1=-0.57, # Temperature exponent 1\n", + " exp_2=-2.33, # Temperature exponent 2\n", + " exp_3=2.4, # Temperature exponent 3\n", + " exp_4=-0.146, # Temperature exponent 4\n", ")\n", "\n", "# Hole mobility model (Caughey-Thomas)\n", "mobility_p = td.CaugheyThomasMobility(\n", - " mu=470.5, # Maximum mobility (cm²/V·s)\n", - " mu_min=44.9, # Minimum mobility (cm²/V·s)\n", - " ref_N=2.23e17, # Reference doping (cm⁻³)\n", - " exp_N=0.719, # Doping exponent\n", - " exp_1=-0.57, # Temperature exponent 1\n", - " exp_2=-2.23, # Temperature exponent 2\n", - " exp_3=2.4, # Temperature exponent 3\n", - " exp_4=-0.146 # Temperature exponent 4\n", + " mu=470.5, # Maximum mobility (cm²/V·s)\n", + " mu_min=44.9, # Minimum mobility (cm²/V·s)\n", + " ref_N=2.23e17, # Reference doping (cm⁻³)\n", + " exp_N=0.719, # Doping exponent\n", + " exp_1=-0.57, # Temperature exponent 1\n", + " exp_2=-2.23, # Temperature exponent 2\n", + " exp_3=2.4, # Temperature exponent 3\n", + " exp_4=-0.146, # Temperature exponent 4\n", ")\n", "\n", "# Effective density of states (constant for isothermal simulation)\n", "# Values at T=300K from Sze & Ng\n", "N_c = td.ConstantEffectiveDOS(N=2.86e19) # Conduction band (cm⁻³)\n", - "N_v = td.ConstantEffectiveDOS(N=3.1e19) # Valence band (cm⁻³)\n", + "N_v = td.ConstantEffectiveDOS(N=3.1e19) # Valence band (cm⁻³)\n", "\n", "# Energy bandgap at 300K\n", - "E_g = td.ConstantEnergyBandGap(eg=1.12) # Silicon bandgap (eV)\n" + "E_g = td.ConstantEnergyBandGap(eg=1.12) # Silicon bandgap (eV)" ] }, { @@ -251,7 +247,7 @@ "# Carrier lifetimes for moderately pure silicon\n", "srh_recombination = td.ShockleyReedHallRecombination(\n", " tau_n=1e-6, # Electron lifetime (s)\n", - " tau_p=1e-6 # Hole lifetime (s)\n", + " tau_p=1e-6, # Hole lifetime (s)\n", ")\n", "\n", "# Radiative recombination (weak in indirect-gap silicon)\n", @@ -262,7 +258,7 @@ "# Auger recombination (important at high doping)\n", "auger_recombination = td.AugerRecombination(\n", " c_n=2.8e-31, # Electron Auger coefficient (cm⁶/s)\n", - " c_p=9.9e-32 # Hole Auger coefficient (cm⁶/s)\n", + " c_p=9.9e-32, # Hole Auger coefficient (cm⁶/s)\n", ")" ] }, @@ -283,10 +279,10 @@ "source": [ "# Bandgap narrowing model (Slotboom)\n", "bandgap_narrowing = td.SlotboomBandGapNarrowing(\n", - " v1=6.92e-3, # Narrowing coefficient (eV)\n", - " n2=1.3e17, # Reference concentration (cm⁻³)\n", - " c2=0.5, # Exponent\n", - " min_N=1e15 # Minimum doping for narrowing (cm⁻³)\n", + " v1=6.92e-3, # Narrowing coefficient (eV)\n", + " n2=1.3e17, # Reference concentration (cm⁻³)\n", + " c2=0.5, # Exponent\n", + " min_N=1e15, # Minimum doping for narrowing (cm⁻³)\n", ")" ] }, @@ -311,30 +307,25 @@ " N_c=N_c,\n", " N_v=N_v,\n", " E_g=E_g,\n", - " N_d=[donor_n_plus], # List of donor doping profiles\n", + " N_d=[donor_n_plus], # List of donor doping profiles\n", " N_a=[acceptor_intrinsic, acceptor_p_plus], # List of acceptor doping profiles\n", " mobility_n=mobility_n,\n", " mobility_p=mobility_p,\n", " R=[srh_recombination, radiative_recombination, auger_recombination],\n", - " delta_E_g=bandgap_narrowing\n", + " delta_E_g=bandgap_narrowing,\n", ")\n", "\n", "# Silicon as a MultiPhysicsMedium\n", - "Si_medium = td.MultiPhysicsMedium(\n", - " charge=si_charge,\n", - " name=\"Si_doped\"\n", - ")\n", + "Si_medium = td.MultiPhysicsMedium(charge=si_charge, name=\"Si_doped\")\n", "\n", "# Aluminum contacts (high conductivity metal)\n", "Al_medium = td.MultiPhysicsMedium(\n", " charge=td.ChargeConductorMedium(conductivity=3.5e7 * 1e-6), # Convert to µm units\n", - " name=\"Al\"\n", + " name=\"Al\",\n", ")\n", "\n", "# Air as background medium\n", - "air = td.MultiPhysicsMedium(\n", - " name=\"air\"\n", - ")" + "air = td.MultiPhysicsMedium(name=\"air\")" ] }, { @@ -352,34 +343,24 @@ "source": [ "# Silicon structures\n", "si_p_structure = td.Structure(\n", - " geometry=td.Box(center=p_center, size=p_size),\n", - " medium=Si_medium,\n", - " name=\"si_p_region\"\n", + " geometry=td.Box(center=p_center, size=p_size), medium=Si_medium, name=\"si_p_region\"\n", ")\n", "\n", "si_i_structure = td.Structure(\n", - " geometry=td.Box(center=i_center, size=i_size),\n", - " medium=Si_medium,\n", - " name=\"si_i_region\"\n", + " geometry=td.Box(center=i_center, size=i_size), medium=Si_medium, name=\"si_i_region\"\n", ")\n", "\n", "si_n_structure = td.Structure(\n", - " geometry=td.Box(center=n_center, size=n_size),\n", - " medium=Si_medium,\n", - " name=\"si_n_region\"\n", + " geometry=td.Box(center=n_center, size=n_size), medium=Si_medium, name=\"si_n_region\"\n", ")\n", "\n", "# Metal contact structures\n", "contact_p_structure = td.Structure(\n", - " geometry=td.Box(center=contact_p_center, size=contact_size),\n", - " medium=Al_medium,\n", - " name=\"contact_p\"\n", + " geometry=td.Box(center=contact_p_center, size=contact_size), medium=Al_medium, name=\"contact_p\"\n", ")\n", "\n", "contact_n_structure = td.Structure(\n", - " geometry=td.Box(center=contact_n_center, size=contact_size),\n", - " medium=Al_medium,\n", - " name=\"contact_n\"\n", + " geometry=td.Box(center=contact_n_center, size=contact_size), medium=Al_medium, name=\"contact_n\"\n", ")\n", "\n", "# Combine all structures\n", @@ -388,7 +369,7 @@ " si_i_structure,\n", " si_p_structure,\n", " contact_n_structure,\n", - " contact_p_structure\n", + " contact_p_structure,\n", "]" ] }, @@ -437,7 +418,7 @@ "ax2.set_ylabel(\"y (µm)\")\n", "\n", "plt.tight_layout()\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -473,22 +454,15 @@ "# Cathode: ground reference (N-contact)\n", "bc_cathode = td.HeatChargeBoundarySpec(\n", " condition=td.VoltageBC(source=td.GroundVoltage()),\n", - " placement=td.StructureStructureInterface(\n", - " structures=[\"contact_n\", \"si_n_region\"]\n", - " )\n", + " placement=td.StructureStructureInterface(structures=[\"contact_n\", \"si_n_region\"]),\n", ")\n", "\n", "# Anode: SSAC voltage source (P-contact)\n", "bc_anode = td.HeatChargeBoundarySpec(\n", " condition=td.VoltageBC(\n", - " source=td.SSACVoltageSource(\n", - " voltage=reverse_bias_voltages,\n", - " amplitude=ac_amplitude\n", - " )\n", + " source=td.SSACVoltageSource(voltage=reverse_bias_voltages, amplitude=ac_amplitude)\n", " ),\n", - " placement=td.StructureStructureInterface(\n", - " structures=[\"contact_p\", \"si_p_region\"]\n", - " )\n", + " placement=td.StructureStructureInterface(structures=[\"contact_p\", \"si_p_region\"]),\n", ")\n", "\n", "boundary_specs = [bc_cathode, bc_anode]" @@ -510,9 +484,9 @@ "outputs": [], "source": [ "# Frequency range for SSAC analysis (Hz)\n", - "freq_min = 1e8 # 100 Mhz\n", + "freq_min = 1e8 # 100 Mhz\n", "freq_max = 1e11 # 100 GHz\n", - "n_freqs_per_decade = 5 # Number of frequency points per decade\n", + "n_freqs_per_decade = 5 # Number of frequency points per decade\n", "\n", "freq_range = td.FreqRange.from_freq_interval(freq_min, freq_max)\n", "freqs = freq_range.sweep_decade(n_freqs_per_decade)" @@ -535,18 +509,12 @@ "source": [ "# Monitor for free carrier concentration\n", "carrier_monitor = td.SteadyFreeCarrierMonitor(\n", - " center=(0, 0, 0),\n", - " size=(td.inf, td.inf, td.inf),\n", - " name=\"carriers\",\n", - " unstructured=True\n", + " center=(0, 0, 0), size=(td.inf, td.inf, td.inf), name=\"carriers\", unstructured=True\n", ")\n", "\n", "# Monitor for electric potential\n", "potential_monitor = td.SteadyPotentialMonitor(\n", - " center=(0, 0, 0),\n", - " size=(td.inf, td.inf, td.inf),\n", - " name=\"potential\",\n", - " unstructured=True\n", + " center=(0, 0, 0), size=(td.inf, td.inf, td.inf), name=\"potential\", unstructured=True\n", ")\n", "\n", "monitors = [carrier_monitor, potential_monitor]" @@ -569,19 +537,19 @@ "source": [ "# Solver tolerance settings\n", "charge_tolerance = td.ChargeToleranceSpec(\n", - " rel_tol=1e-5, # Relative tolerance\n", - " abs_tol=1e16, # Absolute tolerance (cm⁻³)\n", - " max_iters=400, # Maximum iterations\n", - " ramp_up_iters=1 # Ramping iterations for convergence\n", + " rel_tol=1e-5, # Relative tolerance\n", + " abs_tol=1e16, # Absolute tolerance (cm⁻³)\n", + " max_iters=400, # Maximum iterations\n", + " ramp_up_iters=1, # Ramping iterations for convergence\n", ")\n", "\n", "# SSAC analysis specification\n", "analysis_spec = td.IsothermalSSACAnalysis(\n", " tolerance_settings=charge_tolerance,\n", - " convergence_dv=0.1, # Voltage convergence criterion (V)\n", - " fermi_dirac=False, # Use Maxwell-Boltzmann statistics (faster, adequate for moderate doping)\n", - " temperature=300, # Ambient temperature (K)\n", - " freqs=freqs.tolist() # Frequency list for AC analysis\n", + " convergence_dv=0.1, # Voltage convergence criterion (V)\n", + " fermi_dirac=False, # Use Maxwell-Boltzmann statistics (faster, adequate for moderate doping)\n", + " temperature=300, # Ambient temperature (K)\n", + " freqs=freqs.tolist(), # Frequency list for AC analysis\n", ")" ] }, @@ -601,22 +569,22 @@ "outputs": [], "source": [ "# Base mesh resolution\n", - "dl_bulk = 0.04 # Bulk mesh size (µm)\n", + "dl_bulk = 0.04 # Bulk mesh size (µm)\n", "dl_interface = 0.015 # Interface mesh size (µm)\n", "\n", "# Refined regions near P-I and I-N junctions\n", "refinement_pi = td.GridRefinementRegion(\n", - " center=(0, p_center_y - p_thickness/2, 0),\n", + " center=(0, p_center_y - p_thickness / 2, 0),\n", " size=(device_width, 0.2, 0),\n", " dl_internal=dl_interface / 2,\n", - " transition_thickness=dl_bulk * 10\n", + " transition_thickness=dl_bulk * 10,\n", ")\n", "\n", "refinement_in = td.GridRefinementRegion(\n", - " center=(0, n_center_y + n_thickness/2, 0),\n", + " center=(0, n_center_y + n_thickness / 2, 0),\n", " size=(device_width, 0.2, 0),\n", " dl_internal=dl_interface / 2,\n", - " transition_thickness=dl_bulk * 10\n", + " transition_thickness=dl_bulk * 10,\n", ")\n", "\n", "# Grid specification\n", @@ -628,7 +596,7 @@ " distance_bulk=6 * dl_interface,\n", " sampling=1000,\n", " uniform_grid_mediums=[\"Si_doped\"],\n", - " mesh_refinements=[refinement_pi, refinement_in]\n", + " mesh_refinements=[refinement_pi, refinement_in],\n", ")" ] }, @@ -660,7 +628,7 @@ " boundary_spec=boundary_specs,\n", " analysis_spec=analysis_spec,\n", " monitors=monitors,\n", - " grid_spec=grid_spec\n", + " grid_spec=grid_spec,\n", ")" ] }, @@ -719,7 +687,7 @@ "\n", "# Get the bias voltage and frequency arrays\n", "bias_voltage = reverse_bias_voltages[0]\n", - "frequencies = ac_current.coords['f'].values # Frequency array\n", + "frequencies = ac_current.coords[\"f\"].values # Frequency array\n", "\n", "# Select current at the specified bias voltage\n", "# Note: For 2D simulations, multiply by device depth to get total current\n", @@ -728,12 +696,12 @@ "\n", "fig, ax = plt.subplots(1, 1, figsize=(12, 5))\n", "# Plot conductance\n", - "ax.loglog(frequencies / 1e6, I_ac.real, 'o-', linewidth=2, markersize=6, label='Real(I)')\n", - "ax.loglog(frequencies / 1e6, I_ac.imag, '*-', linewidth=2, markersize=6, label='Imag(I)')\n", - "ax.set_xlabel('Frequency (MHz)', fontsize=12)\n", - "ax.set_ylabel('Current (A)', fontsize=12)\n", - "ax.set_title('Current plot', fontsize=13, fontweight='bold')\n", - "ax.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax.loglog(frequencies / 1e6, I_ac.real, \"o-\", linewidth=2, markersize=6, label=\"Real(I)\")\n", + "ax.loglog(frequencies / 1e6, I_ac.imag, \"*-\", linewidth=2, markersize=6, label=\"Imag(I)\")\n", + "ax.set_xlabel(\"Frequency (MHz)\", fontsize=12)\n", + "ax.set_ylabel(\"Current (A)\", fontsize=12)\n", + "ax.set_title(\"Current plot\", fontsize=13, fontweight=\"bold\")\n", + "ax.grid(True, which=\"both\", alpha=0.3, linestyle=\"--\")\n", "ax.legend(fontsize=11)\n", "\n", "plt.tight_layout()\n", @@ -776,7 +744,7 @@ "\n", "# Convert to more convenient units\n", "C_pF = C * 1e12 # Capacitance in pF\n", - "G_uS = G * 1e6 # Conductance in µS" + "G_uS = G * 1e6 # Conductance in µS" ] }, { @@ -808,23 +776,27 @@ "fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 6))\n", "\n", "# Plot conductance\n", - "ax1.loglog(frequencies / 1e6, G_uS, 'o-', linewidth=2, markersize=6, color='#2E86AB', label='Conductance G')\n", - "ax1.set_xlabel('Frequency (MHz)', fontsize=12)\n", - "ax1.set_ylabel('Conductance (µS)', fontsize=12)\n", - "ax1.set_title('Real Part of Admittance: Conductance', fontsize=13, fontweight='bold')\n", - "ax1.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax1.loglog(\n", + " frequencies / 1e6, G_uS, \"o-\", linewidth=2, markersize=6, color=\"#2E86AB\", label=\"Conductance G\"\n", + ")\n", + "ax1.set_xlabel(\"Frequency (MHz)\", fontsize=12)\n", + "ax1.set_ylabel(\"Conductance (µS)\", fontsize=12)\n", + "ax1.set_title(\"Real Part of Admittance: Conductance\", fontsize=13, fontweight=\"bold\")\n", + "ax1.grid(True, which=\"both\", alpha=0.3, linestyle=\"--\")\n", "ax1.legend(fontsize=11)\n", "\n", "# Plot capacitance\n", - "ax2.loglog(frequencies / 1e6, C_pF, 'o-', linewidth=2, markersize=6, color='#A23B72', label='Capacitance C')\n", - "ax2.set_xlabel('Frequency (MHz)', fontsize=12)\n", - "ax2.set_ylabel('Capacitance (pF)', fontsize=12)\n", - "ax2.set_title('Imaginary Part of Admittance: Capacitance', fontsize=13, fontweight='bold')\n", - "ax2.grid(True, which='both', alpha=0.3, linestyle='--')\n", + "ax2.loglog(\n", + " frequencies / 1e6, C_pF, \"o-\", linewidth=2, markersize=6, color=\"#A23B72\", label=\"Capacitance C\"\n", + ")\n", + "ax2.set_xlabel(\"Frequency (MHz)\", fontsize=12)\n", + "ax2.set_ylabel(\"Capacitance (pF)\", fontsize=12)\n", + "ax2.set_title(\"Imaginary Part of Admittance: Capacitance\", fontsize=13, fontweight=\"bold\")\n", + "ax2.grid(True, which=\"both\", alpha=0.3, linestyle=\"--\")\n", "ax2.legend(fontsize=11)\n", "\n", "plt.tight_layout()\n", - "plt.show()\n" + "plt.show()" ] }, { @@ -862,16 +834,16 @@ ], "source": [ "# Extract potential at the bias voltage\n", - "potential = results[\"potential\"].potential.sel(voltage=bias_voltage, z=0, method='nearest')\n", + "potential = results[\"potential\"].potential.sel(voltage=bias_voltage, z=0, method=\"nearest\")\n", "\n", "# Create figure with subplots\n", "fig, ax = plt.subplots(1, 1, figsize=(10, 6))\n", "\n", "# Plot potential\n", - "potential.plot(ax=ax, cmap='viridis', grid=False)\n", - "ax.set_title(f'Electric Potential at {bias_voltage:.1f}V', fontsize=12, fontweight='bold')\n", - "ax.set_xlabel('x (µm)')\n", - "ax.set_ylabel('y (µm)')\n", + "potential.plot(ax=ax, cmap=\"viridis\", grid=False)\n", + "ax.set_title(f\"Electric Potential at {bias_voltage:.1f}V\", fontsize=12, fontweight=\"bold\")\n", + "ax.set_xlabel(\"x (µm)\")\n", + "ax.set_ylabel(\"y (µm)\")\n", "\n", "plt.tight_layout()\n", "plt.show()"