luke
/
IHP-AnalogAcademy
mirror of https://github.com/IHP-GmbH/IHP-AnalogAcademy.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix redundancy and fix module 1

This commit is contained in:
PhillipRambo 2026-02-02 13:01:52 +01:00
parent f3be45acc4
commit 59482b70f9
4 changed files with 17 additions and 1656 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
modules/module_1_bandgap_reference/part_1_OTA/schematic/test.sch
View File

17
modules/module_1_bandgap_reference/part_1_OTA/schematic/xschemrc Normal file
View File

@ -0,0 +1,17 @@
# xschemrc - Custom configuration file for xschem
# This file sources another xschemrc file from a known location
# Source the base configuration from a known location
source $::env(PDK_ROOT)/$::env(PDK)/libs.tech/xschem/xschemrc
# (Optional) Add any custom overrides or extensions below
# set xschem_library_path /home/user/my_libs
# set xschem_gui_font "Monospace 10"
#### include skywater libraries. Here I use [pwd]. This works if I start xschem from here.
###only if you dont have this setup already ###
###append XSCHEM_LIBRARY_PATH :[file dirname [info script]]

949
modules/module_1_bandgap_reference/part_1_OTA/scripting/OTA_low_gain.ipynb
View File

File diff suppressed because one or more lines are too long

707
modules/module_1_bandgap_reference/part_1_OTA/scripting/Untitled.ipynb
View File

@ -1,707 +0,0 @@
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"id": "77c55b20-6f03-4db8-a5ac-7ca94c5f1368",
"metadata": {},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"from mosplot.plot import load_lookup_table, Mosfet, Expression\n",
"import ipywidgets as widgets\n",
"from ipywidgets import interactive\n",
"from ipywidgets import interactive_output, HBox, VBox\n",
"import matplotlib.ticker as ticker "
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "02428279-5305-4a97-9369-a67d6e9ae064",
"metadata": {},
"outputs": [],
"source": [
"lookup_table_nmos = load_lookup_table('../../../module_0_foundations/sg13_nmos_lv_LUT.npz')\n",
"lookup_table_pmos = load_lookup_table('../../../module_0_foundations/sg13_pmos_lv_LUT.npz')"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "167c39d0-87f8-42a0-a4c9-5145a786ad01",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"dict_keys(['sg13_lv_nmos ', 'description', 'simulator', 'parameter_names', 'device_parameters'])\n"
]
}
],
"source": [
"print(lookup_table_nmos.keys())"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "1424aa71-d1c5-45d0-95f4-8fe27a7df89c",
"metadata": {},
"outputs": [],
"source": [
"nmos = Mosfet(lookup_table=lookup_table_nmos, mos=\"sg13_lv_nmos \", vbs=0.0, vds=0.6)\n",
"pmos = Mosfet(lookup_table=lookup_table_pmos, mos=\"sg13_lv_pmos\", vbs=0.0, vds=-0.6, vgs=(-1.2, -0.15))\n",
"\n",
"rows_0, cols_0 = np.shape(nmos.extracted_table['gm']) # just for getting the shape of the data\n",
"rows_1, cols_1 = np.shape(pmos.extracted_table['gm']) # just for getting the shape of the data\n",
"reshaped_lengths_nmos = np.tile(nmos.length[:, np.newaxis], (1, cols_0))\n",
"reshaped_lengths_pmos = np.tile(pmos.length[:, np.newaxis], (1, cols_1))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "1f85ca78-e674-4abc-a350-849dc5fe857f",
"metadata": {
"jupyter": {
"source_hidden": true
}
},
"outputs": [],
"source": [
"def plot_data_vs_data(x_values, y_values, z_values, length, x_axis_name, y_axis_name='y', y_multiplier=1, log=False):\n",
" x_values_flat = np.array(x_values).flatten()\n",
" y_values_flat = np.array(y_values, dtype=np.float64).flatten()\n",
" z_values_flat = np.array(z_values, dtype=np.float64).flatten()\n",
" length_flat = np.array(length).flatten()\n",
"\n",
" # Ensure all inputs have the same length\n",
" if not (len(x_values_flat) == len(y_values_flat) == len(z_values_flat) == len(length_flat)):\n",
" raise ValueError(\"All input arrays (x_values, y_values, z_values, length) must have the same number of elements.\")\n",
"\n",
" unique_lengths = np.unique(length_flat)\n",
" unique_lengths_in_micro = unique_lengths * 1e6\n",
"\n",
" def update_plot(selected_length, x_value=None, y_value=None):\n",
" plt.figure(figsize=(12, 8)) # Make the figure wider (adjust as needed)\n",
"\n",
" if selected_length == \"Show All\":\n",
" mask = np.ones_like(length_flat, dtype=bool)\n",
" else:\n",
" selected_length_in_micro = float(selected_length.replace(' μm', ''))\n",
" tolerance = 0.01 # Tighten the tolerance to avoid unwanted data points\n",
" mask = np.abs(length_flat * 1e6 - selected_length_in_micro) < tolerance\n",
"\n",
" # Apply the mask to the data\n",
" x_values_for_length = x_values_flat[mask]\n",
" y_values_for_length = y_values_flat[mask] * y_multiplier\n",
" z_values_for_length = z_values_flat[mask]\n",
" length_for_length = length_flat[mask] * 1e6\n",
"\n",
" if selected_length == \"Show All\":\n",
" for length_value in np.unique(length_for_length):\n",
" mask_all = (length_for_length == length_value)\n",
" plt.plot(x_values_for_length[mask_all], y_values_for_length[mask_all])\n",
"\n",
" min_length = np.min(unique_lengths_in_micro)\n",
" max_length = np.max(unique_lengths_in_micro)\n",
" plt.title(f'{y_axis_name} vs {x_axis_name} (Length from {min_length:.2f} μm to {max_length:.2f} μm)')\n",
"\n",
" else:\n",
" plt.plot(x_values_for_length, y_values_for_length)\n",
" plt.title(f'{y_axis_name} vs {x_axis_name} for {selected_length}')\n",
"\n",
" plt.xlabel(f'{x_axis_name}')\n",
" plt.ylabel(f'{y_axis_name}')\n",
"\n",
" if log:\n",
" plt.yscale('log')\n",
" plt.gca().yaxis.set_major_locator(ticker.LogLocator(base=10, subs=[], numticks=10))\n",
" plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(lambda x, _: f'$10^{int(np.log10(x))}$'))\n",
" plt.ylabel(f'{y_axis_name} (Log Base 10)')\n",
"\n",
" if y_value is not None and x_value_widget.disabled:\n",
" closest_index = np.abs(y_values_for_length - y_value).argmin()\n",
" closest_x = x_values_for_length[closest_index]\n",
" closest_y = y_values_for_length[closest_index]\n",
" corresponding_z = z_values_for_length[closest_index]\n",
"\n",
" plt.scatter(closest_x, closest_y, color='blue', label=f'Point ({closest_x:.2f}, {closest_y:.2f})')\n",
" z_value_widget.value = corresponding_z\n",
" print(f\"The corresponding {x_axis_name} value for {y_axis_name} = {closest_y:.2f} is: {closest_x:.2f}\")\n",
" elif x_value is not None and y_value_widget.disabled:\n",
" closest_index = np.abs(x_values_for_length - x_value).argmin()\n",
" closest_x = x_values_for_length[closest_index]\n",
" closest_y = y_values_for_length[closest_index]\n",
" corresponding_z = z_values_for_length[closest_index]\n",
"\n",
" plt.scatter(closest_x, closest_y, color='red', label=f'Point ({closest_x:.2f}, {closest_y:.2f})')\n",
" z_value_widget.value = corresponding_z\n",
" print(f\"The corresponding {y_axis_name} value for {x_axis_name} = {closest_x:.2f} is: {closest_y:.2f}\")\n",
"\n",
" plt.grid(True)\n",
" plt.legend()\n",
" plt.show()\n",
"\n",
" dropdown_options = [\"Show All\"] + [f'{length:.2f} μm' for length in unique_lengths_in_micro]\n",
" length_widget = widgets.Dropdown(\n",
" options=dropdown_options,\n",
" value=dropdown_options[0],\n",
" description='Length:',\n",
" layout=widgets.Layout(width='500px') # Make the dropdown wider\n",
" )\n",
"\n",
" x_value_widget = widgets.FloatText(\n",
" value=np.mean(x_values_flat),\n",
" description=f\"{x_axis_name}:\",\n",
" disabled=False,\n",
" layout=widgets.Layout(width='300px', margin='0 40px 0 0'), # Push input boxes more to the right\n",
" description_width='150px' # Smaller description width\n",
" )\n",
"\n",
" y_value_widget = widgets.FloatText(\n",
" value=None,\n",
" description=f\"{y_axis_name}:\",\n",
" disabled=True,\n",
" layout=widgets.Layout(width='300px', margin='0 40px 0 0'), # Push input boxes more to the right\n",
" description_width='150px' # Smaller description width\n",
" )\n",
"\n",
" z_value_widget = widgets.FloatText(\n",
" value=None,\n",
" description=f\" Vgs:\",\n",
" disabled=True,\n",
" layout=widgets.Layout(width='300px', margin='0 40px 0 0'), # Push input boxes more to the right\n",
" description_width='150px' # Smaller description width\n",
" )\n",
"\n",
" select_x_or_y_widget = widgets.Checkbox(\n",
" value=True,\n",
" description=f\"{x_axis_name} (uncheck for {y_axis_name})\",\n",
" layout=widgets.Layout(width='300px') # Make the checkbox wider\n",
" )\n",
"\n",
" def toggle_x_or_y(change):\n",
" if change['new']:\n",
" x_value_widget.disabled = False\n",
" y_value_widget.disabled = True\n",
" else:\n",
" x_value_widget.disabled = True\n",
" y_value_widget.disabled = False\n",
"\n",
" select_x_or_y_widget.observe(toggle_x_or_y, names='value')\n",
"\n",
" output = interactive_output(update_plot, {\n",
" 'selected_length': length_widget,\n",
" 'x_value': x_value_widget,\n",
" 'y_value': y_value_widget\n",
" })\n",
"\n",
" display(VBox([length_widget, select_x_or_y_widget, HBox([x_value_widget, y_value_widget]), z_value_widget, output]))\n",
"\n",
"\n",
"def display_resistance(ro_value):\n",
" \"\"\"Determine the resistance value and its unit.\"\"\"\n",
" if ro_value < 1e3:\n",
" return ro_value, \"Ω\"\n",
" elif ro_value < 1e6:\n",
" return ro_value / 1e3, \"kΩ\"\n",
" elif ro_value < 1e9:\n",
" return ro_value / 1e6, \"MΩ\"\n",
" else:\n",
" return ro_value / 1e9, \"GΩ\"\n",
"\n",
"def display_current(Id_value):\n",
" \"\"\"Determine the current value and its unit.\"\"\"\n",
" if Id_value < 1e-6:\n",
" return Id_value * 1e9, \"nA\" # Convert to nA\n",
" elif Id_value < 1e-3:\n",
" return Id_value * 1e6, \"μA\" # Convert to μA\n",
" else:\n",
" return Id_value * 1e3, \"mA\" # Convert to mA\n",
" \n",
"def dB_to_linear(av_db):\n",
" return 10 ** (av_db / 20)\n",
"\n",
"\n",
"def determine_inversion_region(gm_id_value, device_type):\n",
" \"\"\"Determine the inversion region based on gm/id value for NMOS or PMOS.\"\"\"\n",
" if device_type == 'nmos':\n",
" if gm_id_value > 20:\n",
" return \"Weak Inversion\"\n",
" elif 10 < gm_id_value <= 20:\n",
" return \"Moderate Inversion\"\n",
" else:\n",
" return \"Strong Inversion\"\n",
" elif device_type == 'pmos':\n",
" if gm_id_value > 20:\n",
" return \"Weak Inversion\"\n",
" elif 10 < gm_id_value <= 20:\n",
" return \"Moderate Inversion\"\n",
" else:\n",
" return \"Strong Inversion\"\n",
" else:\n",
" raise ValueError(\"Invalid device type. Use 'nmos' or 'pmos'.\")\n",
" \n"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "a1c721d6-b8b3-4ff3-a9f8-a53360996723",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"5.1895136425091675"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Av_target = 37 # db\n",
"Av_linear = dB_to_linear(Av_target)\n",
"ID = 3e-6\n",
"Cl = 700e-15\n",
"fp1 = 50e3\n",
"Ro = 1/(2*np.pi * fp1 * Cl)\n",
"gm_input = Av_linear / Ro\n",
"gmid_input_transistor = gm_input / ID\n",
"\n",
"gmid_input_transistor"
]
},
{
"cell_type": "markdown",
"id": "7231cd36-89ea-4936-a8a5-8b74bf2d72a3",
"metadata": {},
"source": [
"\n",
"\n",
"$$A_v = gm_{1,2} \\cdot R_{p} \\vert \\vert R_{n}$$"
]
},
{
"cell_type": "code",
"execution_count": 35,
"id": "32ff6468-fb7e-424d-94f7-a56e77a9c9fc",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"141.58915687682762"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"gmro_input = 2 * Ro * gm_input\n",
"gmro_input"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "e76abc49-8b07-4025-bfe2-6b4fc7068ad9",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "924b76b2c42145feab4bb81a438e59fe",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"pmos = Mosfet(lookup_table=lookup_table_pmos, mos=\"sg13_lv_pmos\", vbs=0, vds=-0.6, vgs=(-1.2, -0.2))\n",
"rows_0, cols_0 = np.shape(pmos.extracted_table['gm'])\n",
"reshaped_lengths_pmos = np.tile(pmos.length[:, np.newaxis], (1, cols_0))\n",
"\n",
"width_values_pmos = pmos.width\n",
"id_values_pmos = pmos.extracted_table['id']\n",
"gm_values_pmos = pmos.extracted_table['gm']\n",
"gds_values_pmos = pmos.extracted_table['gds']\n",
"vgs_values_pmos = pmos.extracted_table['vgs']\n",
"\n",
"plot_data_vs_data(gm_values_pmos/id_values_pmos, gm_values_pmos/gds_values_pmos, vgs_values_pmos, reshaped_lengths_pmos, 'gm/id', 'gds')\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 36,
"id": "134b383c-fd21-4259-8722-cc23fbdb2cf8",
"metadata": {},
"outputs": [],
"source": [
"L_input_pmos = 5.46e-6\n",
"gmro_input_pmos = 212.47"
]
},
{
"cell_type": "code",
"execution_count": 40,
"id": "ca8d0f43-af6c-458c-9a32-c485adfbec09",
"metadata": {},
"outputs": [],
"source": [
"ro_nmos = Ro\n",
"gmid_nmos = 8\n",
"gm_nmos = gmid_nmos * ID\n",
"gmro_nmos = gm_nmos * ro_nmos"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "79cacefc-8128-4024-932f-8dde19397334",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "cc77e54d1181444aaf91be44631bd6b3",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"nmos = Mosfet(lookup_table=lookup_table_nmos, mos=\"sg13_lv_nmos \", vbs=0, vds=0.6, vgs=(0.2, 1.0))\n",
"rows_0, cols_0 = np.shape(nmos.extracted_table['gm'])\n",
"reshaped_lengths_nmos = np.tile(nmos.length[:, np.newaxis], (1, cols_0))\n",
"\n",
"width_values_nmos = nmos.width\n",
"id_values_nmos = nmos.extracted_table['id']\n",
"gm_values_nmos = nmos.extracted_table['gm']\n",
"gds_values_nmos = nmos.extracted_table['gds']\n",
"vgs_values_nmos = nmos.extracted_table['vgs']\n",
"\n",
"plot_data_vs_data(gm_values_nmos/id_values_nmos, gm_values_nmos/gds_values_nmos, vgs_values_nmos, reshaped_lengths_nmos, 'gm/id', 'gm/gds')"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "480c32fb-97b8-4449-a33e-62ecf34d3eb1",
"metadata": {},
"outputs": [],
"source": [
"L_nmos = 9.98e-6\n",
"gmro_nmos = 64.7"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "6d86bb64-8379-4adf-b359-420ab40ddc39",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "4f68e95fe4f94bc9aad9d0eb6d81f240",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot_data_vs_data(gm_values_nmos/id_values_nmos,id_values_nmos/width_values_nmos, vgs_values_nmos, reshaped_lengths_nmos, 'gm/id', 'nmos id/W', log=True)"
]
},
{
"cell_type": "code",
"execution_count": 41,
"id": "dbaad6ad-7e73-4f58-aa78-56076d533339",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.0927835051546395e-06"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"idW_nmos = 0.97\n",
"W_nmos = ID/ idW_nmos\n",
"W_nmos"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "81dbc8a8-e36b-4650-9c2d-07bab20549ed",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "362f09b79e1044459a3af3f4d6947fa9",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot_data_vs_data(gm_values_pmos/id_values_pmos,id_values_pmos/width_values_pmos, vgs_values_pmos, reshaped_lengths_pmos, 'gm/id', 'nmos id/W', log=True)"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "e465a920-5804-4fc2-8b91-017dba75432f",
"metadata": {},
"outputs": [],
"source": [
"idW_pmos = 1.09\n",
"W_pmos = ID / idW_pmos"
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "dbf037be-ea06-4028-b70c-206d6ff85bc0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"PMOS Width (W_pmos): 2.75 µm\n",
"PMOS Length (L_input_pmos): 5.46 µm\n",
"NMOS Width (W_nmos): 3.09 µm\n",
"NMOS Length (L_nmos): 6.24 µm\n",
"Tail Current: 6.0 µA\n"
]
}
],
"source": [
"print(f\"PMOS Width (W_pmos): {W_pmos * 1e6:.2f} µm\")\n",
"print(f\"PMOS Length (L_input_pmos): {L_input_pmos * 1e6:.2f} µm\")\n",
"print(f\"NMOS Width (W_nmos): {W_nmos * 1e6:.2f} µm\")\n",
"print(f\"NMOS Length (L_nmos): {L_nmos * 1e6:.2f} µm\")\n",
"print(f\"Tail Current: {(ID * 2)*1e6} µA\")\n"
]
},
{
"cell_type": "code",
"execution_count": 44,
"id": "1fc5f6e3-a883-4fc7-83be-1526cc9437e7",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"53.10132372968084"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# total gain\n",
"gm_nmos = gmid_nmos * ID\n",
"ro_nmos = gmro_nmos / gm_nmos\n",
"ro_pmos = gmro_input_pmos / gm_input \n",
"\n",
"RO_actual = (ro_nmos * ro_pmos)/(ro_nmos + ro_pmos)\n",
"Gain_actual = RO_actual * gm_input\n",
"Gain_actual"
]
},
{
"cell_type": "code",
"execution_count": 45,
"id": "3e5d41f5-9044-44dc-b7e5-b7685cc8ac63",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"np.float64(34.50189042162938)"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"20*np.log10(53.1)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"id": "5400e7cd-6cdf-4e4b-ab71-ecc7e34de299",
"metadata": {},
"outputs": [],
"source": [
"#current_mirror_pmos\n",
"CMpmos_gmid = 18\n",
"Itail = 2 * ID"
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "2cd011c5-0085-430b-baa0-9028055bd9a8",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "57a8fd87b3e84375885c798bc7ea9c4a",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"pmos = Mosfet(lookup_table=lookup_table_pmos, mos=\"sg13_lv_pmos\", vbs=0, vds=-0.2, vgs=(-1.2, -0.2))\n",
"rows_0, cols_0 = np.shape(pmos.extracted_table['gm'])\n",
"reshaped_lengths_pmos = np.tile(pmos.length[:, np.newaxis], (1, cols_0))\n",
"\n",
"width_values_pmos = pmos.width\n",
"id_values_pmos = pmos.extracted_table['id']\n",
"gm_values_pmos = pmos.extracted_table['gm']\n",
"gds_values_pmos = pmos.extracted_table['gds']\n",
"vgs_values_pmos = pmos.extracted_table['vgs']\n",
"\n",
"plot_data_vs_data(gm_values_pmos/id_values_pmos, gm_values_pmos/gds_values_pmos, vgs_values_pmos, reshaped_lengths_pmos, 'gm/id', 'gds')\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"id": "6105f41d-e41a-45fc-ab46-b34b548d5fe7",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "d4eea71adbd744979cbe7dec81e8c851",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
"VBox(children=(Dropdown(description='Length:', layout=Layout(width='500px'), options=('Show All', '0.13 μm', '…"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot_data_vs_data(gm_values_pmos/id_values_pmos,id_values_pmos/width_values_pmos, vgs_values_pmos, reshaped_lengths_pmos, 'gm/id', 'nmos id/W', log=True)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"id": "8f728126-050d-47ed-aebd-ebfef064e941",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6.666666666666667e-05"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"CM_pmos_L = 9.98e-6\n",
"id_over_w_CM_pmos = 0.03\n",
"W = Itail / id_over_w_CM_pmos\n",
"W"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d151c9a6-22d5-45f7-a4c8-a8a08f081d4f",
"metadata": {},
"outputs": [],
"source": []
}
],
"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.10.12"
}
},
"nbformat": 4,
"nbformat_minor": 5
}