PRIMER BLOQUE – METODOS NUMERICOS

TRABAJO COLABORATIVO – SEMANAS 3, 4 y 5

ANDRÈS GARCÌA LÒPEZ - 1921980142

JORGE HERNAN CASTRO QUINTANA (1921983235)

ALEJANDRO JIMÈNEZ CORREA (1911981338)

ALVARO SANTIAGO OROZCO RODRIGUEZ (1721981020)

Presentado a:
JAIME ANDRÈS POSADA RESTREPO
Tutor Virtual

INSTITUCION UNIVERSITARIA POLITÉCNICO GRANCOLOMBIANO

FACULTAD DE INGENIERÍA, DISEÑO E INNOVACION
DEPARTAMENTO DE CIENCIAS BASICAS
INGENIERIA DEL SOFTWARE
2020
Tabla de Contenidos ii

Ejercicio planteado para las semanas 3, 4 y 5 ..............................................................................1

Código Python ............................................................................................................................2
Captura de procedimientos Imágenes ......................................... ¡Error! Marcador no definido.
Importación de librerías y base de Datos para desarrollar el ejercicio Imagen 1. ..........................6
Filtrado de datos RADI Imagen 2. ...............................................................................................6
Filtrado por tiempo Imagen 3. .....................................................................................................6
Procesado de datos filtrados Imagen 4. ........................................................................................7
Aplicación de trazadores cúbicos sobre los datos Imagen 5. ........................................................7
Función de graficado Imagen 6. ..................................................................................................8
Grafica RADI Imagen 7. .............................................................................................................8
Función Área Imagen 8. ..............................................................................................................9
Comprobación algoritmos Imagen 9. ...........................................................................................9
Resultados ...................................................................................................................................9
 1

Ejercicio planteado para las semanas 3, 4 y 5

Propósito En la estación de monitoreo ambiental (EMA) del Politécnico

Grancolombiano ubicada en el Campus Principal de la ciudad de Bogotá, se
cuenta con un piranómetro que mide la radiación solar Ee(t) (en W/m2 ) incidente
sobre la superficie del Campus Principal. A continuación, se encuentra el
comportamiento de dicha magnitud durante el 29 de octubre de 2019. Muchas
veces es necesario calcular la exposición radiante He (en J/m2 ) durante un
determinado periodo de tiempo, esto es He = Z tf ti Ee(τ ) dτ donde ti es un tiempo
inicial y tf es un tiempo final.

El propósito del proyecto es medir entonces He para un determinado día, usando

los registros históricos de datos entregados por EMA y técnicas del módulo de
métodos numéricos.

Fases Para formular el proyecto y diseñar una solución, se recomienda seguir las
siguientes fases:

1. Reconstruir la función Ee(t). Los datos que transmite EMA ocurren cada minuto.
En aproximadamente doce horas de exposición solar se tienen entonces
alrededor de 720 puntos para reconstruir a Ee(t). Usar directamente el polinomio
interpolante puede no ser conveniente, pues su grado será (seguramente)
bastante alto y se presentaran oscilaciones fuertes. Para solucionar estos
problemas, se deberá usar la técnica de trazadores cúbicos.

2. Integrar. Dada la naturaleza de un trazador cubico, es posible integrar cada uno

de sus trozos entre su punto inicial y su punto final. Lo anterior no debería ser
complicado, pues se cuenta con funciones polinomiales de grado a lo más tres.
Finalmente acumular todos los resultados intermedios para obtener el valor final
de He.

Ayudas En el repositorio oficial del curso se encuentra un programa auxiliar que

implementa los trazadores cúbicos. De igual manera, se encuentran en el
directorio reportes consolidados gráficos del comportamiento de cada día,
mientras que en el directorio datos, se tienen archivos csv con los datos en bruto
registrados por EMA. Dichos archivos son el insumo esencial del proyecto y se
debe usar aquel señalado en la consigna del foro. Para comenzar, se deben
identificar los números de los renglones r0 y rk del archivo de datos cuando
ocurren el amanecer el atardecer respectivamente. Usar la columna [RADI] y notar
que valores negativos corresponden a horas nocturnas. El atardecer y amanecer
corresponde entonces a cuando ocurren cambios de signo y no se presentan
oscilaciones. A continuación, usar el conjunto de datos {(t0, y0),(t1, y1), . . . ,(tk,
yk)} para calcular el trazador cubico y el ´área bajo la curva, donde yi es el valor
de radiación (datos de la columna con encabezado [RADI]) correspondiente al
 2

renglón ri , y ti = 60(ri − 2). La anterior fórmula para calcular los tiempos, se debe
a que el primer renglón del archivo de datos son encabezados, y por tanto deben
ser ignorados a la hora de representar los segundos transcurridos del día.
Después de haber implementado todas las fases del proyecto, para evaluar sus
algoritmos se tiene el siguiente caso de prueba: Datos: (60, 5.5), (120, 7.4), (180,
15.4), (240, 20.1). Salida: 2119.2. 4.

Entrega En el foro dispuesto para la entrega del trabajo colaborativo se deben

mostrar evidencias de los avances en la solución del problema. Para ello, cada
integrante debe hacer aportes significativos, que, para la semana final, se deben
consolidar en un único documento grupal. Incluir en dicho documento capturas de
pantalla de las herramientas usadas, códigos fuente, explicaciones, y el resultado
final de la exposición radiante. Adjuntar al foro en formato pdf como evidencia final
del grupo a ser calificada

Solución al trabajo Colaborativo:

Este es el Código Python utilizado para el desarrollo del ejercicio:

# -*- coding: utf-8 -*-

 3

"""Untitled0.ipynb

"""
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from math import *

data_frame = pd.read_csv('DatosEMA-2020-03-26.csv', index_col=0)

data_frame.index = pd.to_datetime(data_frame.index)
series = data_frame[['[RADI]']]
print(series.head())

series_sample = series[(series.index.hour>=6)&(series.index.hour<18)]
print(series_sample)

processed_series_sample = [(60 * i, float(series_sample.values[i])) for i in

range(len(series_sample))]
print(processed_series_sample)

def CubicSplines(datos):
"""
Implementación trazadores cúbicos
Entradas:
datos -- lista de puntos (x, y) en el plano ordenados por x

Salidas:
a -- vector de coeficientes (constantes)
b -- vector de coeficientes (lineales)
c -- vector de coeficientes (cuadráticos)
d -- vector de coeficientes (cúbicos)
"""
n = len(datos)-1
# Inicializar vectores auxiliares
A = [x[1] for x in datos]
X = [x[0] for x in datos]
H = [0.0 for x in range(n)]
B = [0.0 for x in range(n+1)]
C = [0.0 for x in range(n+1)]
D = [0.0 for x in range(n+1)]
alpha = [0.0 for x in range(n)]
mu = [0.0 for x in range(n+1)]
lo = [1.0 for x in range(n+1)]
 4

z = [0.0 for x in range(n+1)]

# Crear vector $H$

for i in range(n):
H[i] = X[i+1]-X[i]

# Crear vector $\alpha$

for i in range(1, n):
alpha[i] = (3/H[i])*(A[i+1]-A[i])-(3/H[i-1])*(A[i]-A[i-1])

# Solucionar sistema tridiagonal

for i in range(1, n):
lo[i] = 2*(X[i+1]-X[i-1])-H[i-1]*mu[i-1]
mu[i] = H[i]/lo[i]
z[i] = (alpha[i]-H[i-1]*z[i-1])/lo[i]

# Solucionar sistema tridiagonal

for j in range(n-1, -1, -1):
C[j] = z[j]-mu[j]*C[j+1]
B[j] = (A[j+1]-A[j])/(H[j])-H[j]*(C[j+1]+2*C[j])/3
D[j] = (C[j+1]-C[j])/(3*H[j])

# Retornar vectores $A$, $B$, $C$, $D$

return A[:-1], B[:-1], C[:-1], D[:-1]

a, b, c, d = CubicSplines(processed_series_sample)
print('A = ', a)
print('B = ', b)
print('C = ', c)
print('D = ', d)

def plot_cubic_spline(x, A, B, C, D, n):

graph_x = np.array([])
graph_y = np.array([])

for idx in range(len(x)-1):

x_i = x[idx]
x_j = x[idx+1]

a, b, c, d = A[idx], B[idx], C[idx], D[idx]

sample = np.linspace(x_i, x_j, n)

eval_sample = a + b*(sample-x_i) + c*(sample-x_i)**2 + d*(sample-
x_i)**3
 5

graph_x = np.concatenate((graph_x, sample))

graph_y = np.concatenate((graph_y, eval_sample))

return graph_x, graph_y

x = [x[0] for x in processed_series_sample]

n = 1000

graph_x, graph_y = plot_cubic_spline(x, a, b, c, d, n)

plt.plot(graph_x, graph_y)
plt.fill_between(graph_x, graph_y)
plt.title('[RADI]')
plt.xticks([])
plt.savefig('RADI.png', dpi=300)

def calculate_area(x, A, B, C, D):

area = 0

for idx in range(len(x)-1):

delta = x[idx+1] - x[idx]

a, b, c, d = A[idx], B[idx], C[idx], D[idx]

sub_area = a * delta + b *delta**2/2 + c *delta**3/3 + d *delta**4/4

area += sub_area

return area

area = calculate_area(x, a, b, c, d)
print(area)

test = [(60, 5.5), (120, 7.4), (180, 15.4), (240, 20.1)]

x = [point[0] for point in test]
A, B, C, D = CubicSplines(test)
test_area = calculate_area(x, A, B, C, D)
print(test_area)
 6

Captura de procedimientos (Imagenes)

Importación de librerías y base de Datos para desarrollar el ejercicio

(Imagen 1).

Filtrado de datos RADI (Imagen 2).

Filtrado por tiempo (Imagen 3).

 7

Procesado de datos filtrados (Imagen 4).

Aplicación de trazadores cúbicos sobre los datos (Imagen 5).

 8

Función de graficado (Imagen 6).

Grafica RADI (Imagen 7).

 9

Función Área (Imagen 8).

Comprobación algoritmos (Imagen 9).

Resultados

Los resultados se ven reflejados cuando se ejecutan los comandos en Python

acá una breve descripción de los resultados obtenidos al ejecutar en Python cada
una de las funciones.

Como primera medida debemos de migrar la base de datos que nos da el

ejercicio a python para que de allí nos arrastre los datos que necesitamos para
la ecuación.
 10

Para esto descargue el software de anaconda, y desde allí abro Jupyter lo cual
me permite abrir una ventana de python en la carpeta donde descargue el
archivo de excel.

ahora que abro Python lo que hago es llamar ese archivo con los datos para lo
cual utilizo el código e importo los datos que voy a necesitar en el proyecto.
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from math import *

pd.read_csv('MNUM_TC_datos_DatosEMA-2020-03-26.csv')
como se visualiza en la siguiente imagen
 11

Como vemos nos muestra que tenemos 1440 datos en la base pero solo
necesitamos los datos desde las 6 am hasta las 6 pm ya que antes y después de
esta hora la radiación es negativa porque aun no ha amanecido.
Para solo traer las dos columnas que necesitamos que son tiempo y radiación
utilizamos el siguiente cogido
data_frame = pd.read_csv('MNUM_TC_datos_DatosEMA-2020-03-26.csv',
index_col=0)
data_frame.index = pd.to_datetime(data_frame.index)
series = data_frame[['[RADI]']]
print(series.head())
Como se ve representado en la siguiente imagen

Listo en base a estas dos columnas es que vamos a realizar nuestros cálculos,
pero recordemos que aún nos falta sacar la columna de datos de antes de las
6am y después de las 6 pm para eso utilizamos la siguiente formula
series_sample = series[(series.index.hour>=6)&(series.index.hour<18)]
print(series_sample)
Demostrado de la siguiente manera

Vemos que ahora tenemos los 720 con los cuales vamos a trabajar.
Ahora necesitamos un punto X y un punto Y los cuales nos van a servir de
referencia en el trabajo, pero para sacar el punto X solo debemos sacar el dato
que varía en el tiempo y son los minutos, los cuales equivalen a 60 segundos
 12

por lo cual el eje X ira desde 0 hasta 43.140 segundos, para ello utilizamos la
siguiente formula
processed_series_sample = [(60 * i, float(series_sample.values [i])) for i in
range(len(series_sample))]
print(processed_series_sample)
y nos queda de la siguiente manera

Solo se recortó parte de la imagen ya que son muchos datos.

Bien ahora si podemos utilizar el algoritmo de trazadores cúbicos que tenemos,
por ejemplo
def CubicSplines(datos):
"""
Implementación trazadores cúbicos
Entradas:
datos -- lista de puntos (x, y) en el plano ordenados por x
Salidas:
a -- vector de coeficientes (constantes)
b -- vector de coeficientes (lineales)
c -- vector de coeficientes (cuadráticos)
d -- vector de coeficientes (cúbicos)
 13

"""
n = len(datos)-1
# Inicializar vectores auxiliares
A = [x[1] for x in datos]
X = [x[0] for x in datos]
H = [0.0 for x in range(n)]
B = [0.0 for x in range(n+1)]
C = [0.0 for x in range(n+1)]
D = [0.0 for x in range(n+1)]
alpha = [0.0 for x in range(n)]
mu = [0.0 for x in range(n+1)]
lo = [1.0 for x in range(n+1)]
z = [0.0 for x in range(n+1)]
# Crear vector
H

for i in range(n):
H[i] = X[i+1]-X[i]
# Crear vector
α

for i in range(1, n):

alpha[i] = (3/H[i])*(A[i+1]-A[i])-(3/H[i-1])*(A[i]-A[i-1])
# Solucionar sistema tridiagonal
for i in range(1, n):
lo[i] = 2*(X[i+1]-X[i-1])-H[i-1]*mu[i-1]
mu[i] = H[i]/lo[i]
z[i] = (alpha[i]-H[i-1]*z[i-1])/lo[i]
# Solucionar sistema tridiagonal
for j in range(n-1, -1, -1):
C[j] = z[j]-mu[j]*C[j+1]
B[j] = (A[j+1]-A[j])/(H[j])-H[j]*(C[j+1]+2*C[j])/3
D[j] = (C[j+1]-C[j])/(3*H[j])
# Retornar vectores
A
,
B
,
C
 14

,
D

return A[:-1], B[:-1], C[:-1], D[:-1]

Ahora vamos a definir los datos para A, B, C, D
Para esto utilizamos la siguiente formula
a, b, c, d = CubicSplines(processed_series_sample)
print('A = ', a)
print('B = ', b)
print('C = ', c)
print('D = ', d)
Quedando de esta manera

También se resumen los datos ya que son muchos para la imagen.

Teniendo estos datos pasamos a desarrollar la gráfica en python y luego de esto
se puede calcular el área.
 15

Las fórmulas para las gráficas son las siguientes

Y para el área es el siguiente código en el cual podemos observar la prueba final

para validar que el programa si funcione correctamente
 16

Lista de referencias
https://arturoguillen90.wordpress.com/interpolacion/trazadores-
cubicos/#:~:text=El%20proceso%20de%20construcci%C3%B3n%20del,i%2C%2
0ci%20y%20di.&text=De%20estas%20condiciones%20podemos%20obtener,%2
C%E2%80%A6%2C%20n%20%E2%88%92%201.

https://www.researchgate.net/publication/328253897_Interpolacion_por_el_meto
do_de_los_Trazadores_Cubicos_Cubic_Splines (Enlaces a un sitio externo.)
https://www.academia.edu/37660702/Los_Trazadores_C%C3%BAbicos_Cubic_
Splines_

https://gitlab.com/japosada/notebooks/-
/blob/master/MNUM/TC/reportes/ReporteEMA-2020-03-26.pdf (Enlaces a un
sitio externo.)
https://arturoguillen90.wordpress.com/interpolacion/trazadores-cubicos

https://gitlab.com/japosada/notebooks/-
/blob/master/MNUM/TC/datos/DatosEMA-2020-03-26.csv (Enlaces a un sitio
externo.)

https://gitlab.com/japosada/notebooks/-
/blob/master/MNUM/TC/reportes/ReporteEMA-2020-03-26.pdf