CÁLCULO DEL TIEMPO DE CARGA DE UN

CAPACITOR POR METODOS NÚMERICOS

INTEGRANTES:
OBJETIVOS:
OBJETIVO GENERAL:
 Determinar el Tiempo de carga
de un capacitador, aplicando la
Regla de Simpson 1/3.
OBJETIVOS ESPECÍFICOS:
• Desarrollaremos el
algoritmo empleando el
Lenguaje de Programación
Python
• Desarrollaremos el
Diagrama de Flujo y
Pseudocódigo
aprovechando el Software
PSeInt
 MARCO TEÓRICO DEL
DESARROLLO (REGLA DE
SIMPSON 1/3):
Método de integración para calcular integrales
definidas donde se conectan grupos sucesivos de
tres puntos sobre la curva mediante parábolas
de segundo grado.

A las fórmulas que resultan

de calcular la integral bajo
estos polinomios se les llama
Reglas de Simpson.
Este método consiste en la aproximación del cálculo del área, bajo una
curva utilizando
trapecios curvilíneos a partir una interpolación con una función
cuadrática:

 
Esta aproximación es denominada “simple” debido a que utiliza tan
sólo un polinomio. Requiere el conocimiento de tres puntos: los
extremos y un punto central.
Aplicando esta expresión para mayor cantidad de puntos
intermedios (es decir, realizando más de un Simpson 1/3 dentro del
intervalo) puede definirse la variante “compuesta” del método para
el cual se utilizan n puntos que corresponden a n = N − 1
subintervalos. Este caso requiere que la cantidad de subintervalos
sean pares (el caso simple utiliza dos, por lo tanto, este debe ser un
múltiplo). Por lo que, se define un valor h que corresponde al paso
que hay entre puntos. Se calcula como h = b−a n.

Finalmente, la aproximación del área se puede calcular como:

DIAGRAMA DE FLUJO:
clic en el icono para agregar una imagen
Haga clic en el icono para agregar una imagen
DESCRIPCIÓN LITERAL DEL ALGORITMO:

Para poder ejecutar este algoritmo en Python importamos la siguiente librería:

numpy
Posterior a la importación de las librerías declaramos las variables que
ocuparemos para simplificar el algoritmo, también usaremos el comando float
para poder trabajar con números decimales.
Declararemos las siguientes variables (vol, cor, cap, inicial, final, diferencia,
diferencia y delta)
Se hace que “diferencia” es igual a la resta entre final e inicial, para luego
multiplicarlo por 10 y sumarle 1.
También declaramos las siguientes variables (abscisas, ordenadas, integ)
como vectores de tamaño igual a “diferencia”.
Y crearemos dos variables más con una igualdad a cero para poder separar
los impares y pares
Vet=0
integ_inpares=0
integ_pares=0
Posteriormente se declara un ciclo “for” para trabajar en la matriz en la
matriz de abscisas y así obtener que cada elemento de la matriz es igual a los
pasos que hay entre “inicial” y “final” con su respectivo “delta”.
Luego para separar los elementos impares de los pares de la matriz
“abscisas” y para ello se usan dos ciclos “for”, los dos con saltos de 2, uno de
ellos empezando desde el segundo elemento hasta el penúltimo sumando los
resultados en “integ_impares” y el otro desde el tercer elemento hasta el
antepenúltimo sumando los resultados en “integ_pares”.
Posteriormente se multiplica por 2 y 4 a “integ_impares” y “integ_pares”
respectivamente.
A continuación, vamos operando en “integrado” sumando el primer número de
la matriz “integ”, “integ_impares”, “integ_pares” y el ultimo número de la
matriz “integ”, luego se lo multiplica por “delta” y se lo divide entre 3.
Luego se calcula “vt” como 1 sobre “cap” por “integrando” más “vol” por
“inicial”
Por último, se muestra “vt”
ALGORITMO:
import numpy as np

vol=float(input("Introduzca el voltage: "))

cor=float(input("Introduzca la corriente: "))
cap=float(input("Introduzca el capacitancia: "))
inicial=float(input("Introduzca el tiempo inicial: "))
final= float(input("Introduzca el tiempo final: "))
diferencia=final-inicial
diferencia=int(diferencia*10+1)
delta=0.1
abcisas=np.array(np.zeros(diferencia))
ordenadas=np.array(np.zeros(np.size(abcisas)))
integ=np.array(np.zeros(np.size(abcisas)))
vt=np.array(np.zeros(np.size(abcisas)))
integ_inpares=0
integ_pares=0

for g in range(0,np.size(abcisas)):
abcisas[g]=inicial+delta*g
integ[g]=cor*abcisas[g]

#Separar "pares de inpares"

for f in range(1,diferencia,2):
integ_inpares=integ[f]+integ_inpares
integ_inpares=integ_inpares*4

for q in range(2,diferencia-1,2):
integ_pares=integ[q]+integ_pares
integ_pares=integ_pares*2

integrado=integ[0]+integ_inpares+integ_pares+integ[diferencia-1]
integrado=integrado*delta
integrado=integrado/3

vt=(1/cap)*integrado+vol*inicial
print(vt)