{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Síntesis de algunas funciones RLC\n",
"\n",
"![](\"./img/logo_UTN.svg\")
\n",
"\n",
"#### Por Mariano Llamedo Soria"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Resumen \n",
"En el siguiente documento se presentan lineamientos para realizar algunas síntesis RLC. Si bien existen métodos sistemáticos para tal fin, en el contexto de la materia Teoría de Circuitos 2, nos interesarán ciertas redes con topologías bien definidas. Para ello enfatizamos la importancia de conocer dicha topología circuital (red no disipativa con doble o simplemente cargada, sin carga, etc.), y utilizarla durante el procedimiento de síntesis como guía para realizar las remociones.\n",
"\n",
"* Dibujo de redes: [dibujar_cauer_RC_RL](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_cauer_RC_RL), [dibujar_foster_derivacion](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_foster_derivacion), [dibujar_foster_serie](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_foster_serie), [dibujar_cierre](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_cierre), [dibujar_funcion_exc_abajo](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_funcion_exc_abajo), [dibujar_tanque_derivacion](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_tanque_derivacion), [dibujar_tanque_RC_serie](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_tanque_RC_serie), [dibujar_elemento_derivacion](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_elemento_derivacion), [dibujar_puerto_entrada](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_puerto_entrada), [dibujar_espacio_derivacion](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_espacio_derivacion), [dibujar_elemento_serie](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_elemento_serie), [dibujar_puerto_salida](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/dibujar/index.html#pytc2.dibujar.dibujar_puerto_salida)\n",
"* Funciones de síntesis de dipolos: [cauer_RC](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.cauer_RC), [foster](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.foster), [foster_zRC2yRC](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/sintesis_dipolo/index.html#pytc2.sintesis_dipolo.foster_zRC2yRC), [remover_valor_en_dc](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/remociones/index.html#pytc2.remociones.remover_valor_en_dc), [remover_valor_en_infinito](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/remociones/index.html#pytc2.remociones.remover_valor_en_infinito), [remover_polo_sigma](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/remociones/index.html#pytc2.remociones.remover_polo_sigma)[remover_polo_dc](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/remociones/index.html#pytc2.remociones.remover_polo_dc), [isFRP](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/remociones/index.html#pytc2.remociones.isFRP)\n",
"* Funciones para presentación de markdown y latex: [print_subtitle](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.print_subtitle), [print_latex](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.print_latex), [a_equal_b_latex_s](https://pytc2.readthedocs.io/en/latest/autoapi/pytc2/general/index.html#pytc2.general.a_equal_b_latex_s)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Introducción\n",
"\n",
"Concluye la sección de síntesis de funciones de excitación dejando algunas pautas para resolver la síntesis de redes R-L-C. Como se explicó en los documentos anteriores para las redes compuestas por dos elementos diferentes, habrá que prestar especial atención en todos los pasos de la síntesis de que la inmitancia remanente no pierda su **condición de ser realizable**, es decir que sea FRP. \n",
"\n",
"Se presentan a continuación algunos ejemplos orientados a resolver ciertos problemas especialmente útiles al momento de sintetizar **transferencias cargadas**. Se remite al lector interesado en métodos sistemáticos a la [bibliografía](https://en.wikipedia.org/wiki/Network_synthesis) (Brune, Bott-Duffin, Miyata, etc.)\n",
"\n",
"Se inicializa el entorno de trabajo para comenzar con el primer ejemplo"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"\n",
"import sympy as sp\n",
"from IPython.display import display, Markdown\n",
"from schemdraw import Drawing\n",
"\n",
"# Ahora importamos las funciones de PyTC2\n",
"\n",
"from pytc2.remociones import remover_polo_dc, remover_polo_infinito, isFRP\n",
"from pytc2.remociones import remover_valor_en_dc, remover_valor_en_infinito, remover_polo_sigma\n",
"\n",
"from pytc2.sintesis_dipolo import cauer_RC, foster, foster_zRC2yRC\n",
"from pytc2.dibujar import dibujar_cauer_RC_RL, dibujar_foster_derivacion, dibujar_foster_serie, dibujar_cierre, dibujar_puerto_entrada, dibujar_funcion_exc_abajo, dibujar_elemento_serie, dibujar_elemento_derivacion, dibujar_tanque_derivacion, dibujar_tanque_RC_serie, dibujar_espacio_derivacion\n",
"from pytc2.general import print_latex, print_subtitle, a_equal_b_latex_s\n",
"\n",
"# Importante importar símbolos de variables \n",
"from pytc2.general import s\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ejemplo 1:\n",
"\n",
"Sea la siguiente función de impedancia:\n",
"\n",
"$$ Z(s) = \\frac{(s^2+2s+2)}{(s^2+s+1)} $$ \n",
"\n",
"Se comienza por la inicialización de variables y la función dada"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Impedancia $Z_{RLC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RLC}(s)=\\frac{s^{2} + 2 s + 2}{s^{2} + s + 1}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\n",
"# Sea la siguiente función de excitación\n",
"ZZ = (s**2 + 2*s + 2)/(s**2 + 1*s + 1)\n",
"\n",
"print_subtitle('Impedancia $Z_{RLC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s('Z_{RLC}(s)', ZZ))\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Expansión Foster de $Z_{RLC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RLC}(s)=\\frac{s^{2} + 2 s + 2}{s^{2} + s + 1}=\\frac{s + 1}{s^{2} + s + 1} + 1$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_0=0$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_1=\\left[ \\left[ 1, \\ 0\\right]\\right]$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_k=1$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Se expande ZRC a la Foster\n",
"k0, koo, ki_wi, kk, ZRLC_foster = foster(ZZ)\n",
"\n",
"print_subtitle('Expansión Foster de $Z_{RLC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('Z_{RLC}(s)', ZZ)[1:-1], ZRLC_foster ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_0', sp.latex(k0)))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_1', sp.latex(ki_wi) ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_k', sp.latex(kk)))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/markdown": [
"#### Expansión Foster de $Y_{RLC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RLC}(s)=\\frac{s^{2} + s + 1}{s^{2} + 2 s + 2}=- \\frac{s + 1}{s^{2} + 2 s + 2} + 1$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_0=0$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_1=\\left[ \\left[ -2, \\ 0\\right]\\right]$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle k_k=1$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Se expande ZRC a la Foster\n",
"k0, koo, ki_wi, kk, YRLC_foster = foster(1/ZZ)\n",
"\n",
"print_subtitle('Expansión Foster de $Y_{RLC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('Y_{RLC}(s)', 1/ZZ)[1:-1], YRLC_foster ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_0', sp.latex(k0)))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_1', sp.latex(ki_wi) ))\n",
"\n",
"print_latex(a_equal_b_latex_s('k_k', sp.latex(kk)))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"como se puede apreciar, ninguna de las formas Foster pareciera llegar a buen puerto para la síntesis, probaremos con Cauer finalmente"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"#################################\n",
"# Fallo la remoción en infinito #\n",
"#################################\n",
"\n",
"Se intentó remover el valor:\n"
]
},
{
"data": {
"text/latex": [
"$\\displaystyle k_{\\infty}=\\infty$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"######################\n",
"# Fallo la expansión #\n",
"######################\n",
"\n"
]
},
{
"data": {
"text/latex": [
"$\\displaystyle \\frac{s^{2} + 2 s + 2}{s^{2} + s + 1} \\neq 1 + \\frac{1}{s}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/markdown": [
"#### Implementación escalera de $Z_{RLC}$ e $Y_{RLC}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RLC}(s)=\\frac{s^{2} + 2 s + 2}{s^{2} + s + 1}=1 + \\frac{1}{s}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RLC}(s)=\\frac{s^{2} + 2 s + 2}{s^{2} + s + 1}=1 + \\frac{1}{s}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"\n",
"# Implementaremos FF mediante Cauer 1 o remociones continuas en infinito\n",
"koo, ZZ_cauer_oo, rem = cauer_RC(ZZ, remover_en_inf=True)\n",
"\n",
"print_subtitle('Implementación escalera de $Z_{RLC}$ e $Y_{RLC}$')\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Z_{RLC}(s)', ZZ)[1:-1], ZZ_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Z\n",
"dibujar_cauer_RC_RL(koo, z_exc = ZZ_cauer_oo)\n",
"\n",
"print_latex(a_equal_b_latex_s(a_equal_b_latex_s('$ Y_{RLC}(s)', ZZ)[1:-1], ZZ_cauer_oo ))\n",
"\n",
"# Tratamos a nuestra función inmitancia como una Y\n",
"dibujar_cauer_RC_RL(koo, y_exc = ZZ_cauer_oo)\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Las formas canónicas no han servido de mucho como era de esperarse. Se procede ahora con una metodología NO canónica, basada simplemente en realizar remociones cuidando que la función resultante no **se rompa**, es decir, deje de ser FRP. Se comienza con la función original:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"isFRP(ZZ)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Obviamente la función original es FRP. Luego se comienza por analizar el comportamiento de la función en ambos extremos y evaluar la red que resulta luego de la remoción. Tanto en 0 como infinito la red se comporta resistivamente. Ahora conviene evaluar el valor de cada tendencia en los extremos, y saber que solo puede removerse **el menor valor**. Para este caso el límite lo impone el valor en infinito:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"Z2, R1 = remover_valor_en_infinito(ZZ)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Si fuese correcto el camino elegido, Z2 debería seguir siendo FRP:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Z2 es FRP? Si\n"
]
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_2(s)=\\frac{s + 1}{s^{2} + s + 1}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"str_si_o_no = ['No', 'Si']\n",
"\n",
"print( 'La función Z2 es FRP? {:s}'.format(str_si_o_no[isFRP(Z2)]) )\n",
"\n",
"print_latex(a_equal_b_latex_s('Z_2(s)', Z2))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Procedemos a analizar la siguiente remoción sobre Z2. En este caso encontramos un comportamiento capacitivo en infinito (cero de impedancia), y el resistivo en DC. Evidentemente, ya no podemos retirar nada salvo el capacitor que se evidencia en infinito. Para ello, invertimos y removemos:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"Y4, Y3 = remover_polo_infinito(1/Z2)\n",
"\n",
"C1 = Y3/s"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ya obtenido C1, repetimos el paso anterior: analizamos Y4 y procedemos a dar el siguiente paso:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Y4 es FRP? Si\n"
]
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_4(s)=\\frac{1}{s + 1}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"print( 'La función Y4 es FRP? {:s}'.format(str_si_o_no[isFRP(Y4)]) )\n",
"\n",
"print_latex(a_equal_b_latex_s('Y_4(s)', Y4))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora está mucho más claro, e identificamos que en Z4 solo restan un inductor y un resistor"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"Z6, Z5 = remover_polo_infinito(1/Y4)\n",
"\n",
"L1 = Z5/s\n",
"\n",
"R2 = Z6"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Con esto finalizamos la síntesis y procedemos a visualizar la red resultante"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"d = dibujar_puerto_entrada( Drawing(unit=4),\n",
" voltage_lbl = ('+', '$V1$', '-'), \n",
" current_lbl = '$I1$')\n",
"\n",
"d = dibujar_funcion_exc_abajo(d, \n",
" 'Z', \n",
" ZZ, \n",
" hacia_salida = True,\n",
" k_gap_width = 0.5)\n",
"\n",
"d = dibujar_elemento_serie(d, 'R', R1)\n",
"\n",
"d = dibujar_elemento_derivacion(d, 'C', C1)\n",
"\n",
"d = dibujar_elemento_serie(d, 'L', L1)\n",
"\n",
"d = dibujar_elemento_serie(d, 'R', R2)\n",
"\n",
"d = dibujar_cierre(d)\n",
"\n",
"display(d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cabe la pregunta ahora, ¿podría haberse tomado otro camino durante la síntesis?\n",
"\n",
"Por ejemplo, ¿podríamos retirar un inductor unitario primero?"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Z2x es FRP? No\n"
]
}
],
"source": [
"Z2x = ZZ - s\n",
"\n",
"print( 'La función Z2x es FRP? {:s}'.format(str_si_o_no[isFRP(Z2x)]) )\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Evidentemente **no** ¿y un capacitor?"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Z2x es FRP? No\n"
]
}
],
"source": [
"Z2x = ZZ - 1/s\n",
"\n",
"print( 'La función Z2x es FRP? {:s}'.format(str_si_o_no[isFRP(Z2x)]) )\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Tampoco es posible**. Esto debería servir para enfatizar la importancia del orden en las remociones. En muchas síntesis RLC, se tiene cierta información previa sobre **la topología circuital**, o alguna característica de la red: una resonancia de algún tanque, un valor de resistencia a cierta frecuencia, etc. Sin dejar de mencionar las síntesis **doblemente cargadas**, posiblemente las síntesis RLC más relevantes para esta materia. En ellas se sabe que tanto en el puerto de entrada como de salida están los componentes resistivos o disipativos, mientras que entre ambos solo podrá haber capacitores e inductores, dada la naturaleza no disipativa de la red. Es decir que en estos casos la topología hace las veces de *mapa de remociones* (al igual que el método gráfico)."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Ejemplo 2:\n",
"\n",
"Sea la siguiente función de impedancia:\n",
"\n",
"$$ Z(s) = \\frac{(s^2+s+1)}{(s^2+2s+5)(s+1)} $$ \n",
"\n",
"Encontrar los valores de los componentes de la siguiente red\n",
"\n",
"\n",
"\n",
"#### Una posible solución\n",
"\n",
"Inicializamos la función requerida"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/markdown": [
"#### Impedancia $Z_{RLC}$ "
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Z_{RLC}(s)=\\frac{s^{2} + s + 1}{\\left(s + 1\\right) \\left(s^{2} + 2 s + 5\\right)}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/latex": [
"$\\displaystyle Y_{RLC}(s)=\\frac{\\left(s + 1\\right) \\left(s^{2} + 2 s + 5\\right)}{s^{2} + s + 1}$"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Sea la siguiente función de excitación\n",
"ZZ = (s**2 + 1*s + 1) / (s**2 + 2*s + 5) / (s + 1)\n",
"\n",
"print_subtitle('Impedancia $Z_{RLC}$ ')\n",
"\n",
"print_latex(a_equal_b_latex_s('Z_{RLC}(s)', ZZ))\n",
"\n",
"print_latex(a_equal_b_latex_s('Y_{RLC}(s)', 1/ZZ))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"como se explicó en el anterior ejemplo, la topología circuital será la guía de las remociones. Como los primeros elementos están en derivación, así debemos proceder: removiendo un **polo en infinito** y un **valor constante**"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"# remoción total en infinito de 1/ZZ\n",
"\n",
"Y2, Yc1 = remover_polo_infinito(1/ZZ)\n",
"\n",
"# Yc1 es la admitancia removida\n",
"# extraigo C1\n",
"C1 = Yc1/s"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Al proceder a remover un valor constante, debe prestarse especial cuidado a **NO remover de más**. Es decir, solo se podrá remover el mínimo valor real de la función en ambos extremos:"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Y4 es FRP? Si\n"
]
}
],
"source": [
"Ginf = sp.limit(Y2, s, sp.oo)\n",
"G0 = sp.limit(Y2, s, 0)\n",
"\n",
"import numpy as np\n",
"\n",
"# remuevo la menor admitancia\n",
"R1 = 1/np.min((Ginf, G0))\n",
"Y4 = sp.factor(sp.simplify(sp.expand(Y2 - 1/R1)))\n",
"\n",
"print( 'La función Y4 es FRP? {:s}'.format(str_si_o_no[isFRP(Y4)]) )\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Evidentemente lo hemos hecho bien. Procedemos ahora a continuar con la topología de la misma manera"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"La función Z8 es FRP? Si\n"
]
}
],
"source": [
"Z6, Zl1 = remover_polo_infinito(1/Y4)\n",
"\n",
"# Zl1 es la impedancia removida\n",
"# extraigo L1\n",
"L1 = Zl1/s\n",
"\n",
"# remuevo la menor resistencia\n",
"Rinf = sp.limit(Z6, s, sp.oo)\n",
"R0 = sp.limit(Z6, s, 0)\n",
"R2 = np.min((Rinf, R0))\n",
"Z8 = sp.factor(sp.simplify(sp.expand(Z6 - R2)))\n",
"\n",
"print( 'La función Z8 es FRP? {:s}'.format(str_si_o_no[isFRP(Z8)]) )"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ahora si, procedemos a los elementos finales"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"# extraigo C2\n",
"C2 = sp.limit(1/s/Z8, s, sp.oo)\n",
"\n",
"Y10, Yc2 = remover_polo_infinito(1/Z8)\n",
"# Yc1 es la admitancia removida\n",
"# extraigo C1\n",
"C2 = Yc2/s\n",
"\n",
"R3 = 1/Y10"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finalmente, dibujamos la red resultante con los valores obtenidos"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
"\n",
"\n",
"\n"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# Dibujamos la red resultante:\n",
"\n",
"d = dibujar_puerto_entrada(Drawing(unit=4),\n",
" voltage_lbl = ('+', '$V$', '-'), \n",
" current_lbl = '$I$')\n",
"\n",
"d = dibujar_funcion_exc_abajo(d, \n",
" 'Z', \n",
" ZZ, \n",
" hacia_salida = True,\n",
" k_gap_width = 0.5)\n",
"\n",
"d = dibujar_elemento_derivacion(d, 'C', C1)\n",
"\n",
"d = dibujar_espacio_derivacion(d)\n",
"\n",
"d = dibujar_elemento_derivacion(d, 'R', R1)\n",
" \n",
"d = dibujar_elemento_serie(d, 'L', L1)\n",
"\n",
"d = dibujar_elemento_serie(d, 'R', R2)\n",
"\n",
"d = dibujar_elemento_derivacion(d, 'C', C2)\n",
"\n",
"d = dibujar_espacio_derivacion(d)\n",
"\n",
"d = dibujar_elemento_derivacion(d, 'R', R3)\n",
"\n",
"display(d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Con este ejemplo se finaliza el documento."
]
}
],
"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.16"
},
"varInspector": {
"cols": {
"lenName": 16,
"lenType": 16,
"lenVar": 40
},
"kernels_config": {
"python": {
"delete_cmd_postfix": "",
"delete_cmd_prefix": "del ",
"library": "var_list.py",
"varRefreshCmd": "print(var_dic_list())"
},
"r": {
"delete_cmd_postfix": ") ",
"delete_cmd_prefix": "rm(",
"library": "var_list.r",
"varRefreshCmd": "cat(var_dic_list()) "
}
},
"types_to_exclude": [
"module",
"function",
"builtin_function_or_method",
"instance",
"_Feature"
],
"window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 4
}