Mira este código, necesito calcular (hazlo aparte sin tocar el cálculo de la sombra…
- User
Mira este código, necesito calcular (hazlo aparte sin tocar el cálculo de la sombra existente) la distancia mínima lateral que está en dependencia de la sombra lateral: import numpy as np from math import sin, cos, radians, degrees, tan, asin import datetime
Funciones de conversión
def deg2rad(degrees_val): return radians(degrees_val)
def rad2deg(radians_val): return degrees(radians_val)
Funciones de cálculo solar
def calcular_x(dia, hora): return (2 * np.pi / 365) * (dia - 1 + ((hora - 12) / 24))
def calcular_declination(x): return (0.006918 - 0.399912 * np.cos(x) + 0.070257 * np.sin(x) - 0.006758 * np.cos(2x) + 0.000907 * np.sin(2x) - 0.002697 * np.cos(3x) + 0.001480 * np.sin(3x))
def calcular_delta_t(x): return (229.18 * (0.00065 + 0.001868 * np.cos(x) - 0.032077 * np.sin(x) - 0.014615 * np.cos(2x) - 0.040849 * np.sin(2x)))
def calcular_t_solar(delta_t, longitud, utc): return delta_t - (4 * longitud) + (60 * utc)
def calcular_elevacion_sol(t_solar, delta, phi): omega = (t_solar / 4) # cada 4 minutos es un grado omega_rad = deg2rad(omega) phi_rad = deg2rad(phi)
sin_theta = (np.cos(omega_rad) * np.cos(delta) * np.cos(phi_rad) + np.sin(delta) * np.sin(phi_rad)) # Asegurarse que sin_theta está en el rango [-1, 1] sin_theta = np.clip(sin_theta, -1, 1) theta_s = asin(sin_theta) # En radianes theta_s_deg = rad2deg(theta_s) return theta_s_deg, sin_thetadef calcular_gamma(beta, theta_s): return 90 + beta - theta_s
def calcular_sombra(distance, Lfv, N_s, Hfv, N_p, beta, gamma, theta_s): L = Lfv * N_s H = Hfv * N_p
beta_rad = deg2rad(beta) gamma_rad = deg2rad(gamma) dn = (distance / H) * np.sin(beta_rad) denominator = (L / H) * np.sin(beta_rad) if denominator == 0: l_s = 0 else: term1 = (dn * np.sin(beta_rad) + np.cos(beta_rad)) / denominator denominator_term2 = (np.cos(beta_rad) * tan(deg2rad(theta_s)) + np.sin(beta_rad) * np.cos(gamma_rad)) if denominator_term2 == 0: term2 = 0 else: term2 = (abs(np.sin(gamma_rad))) / denominator_term2 l_s = 1 - term1 * term2 l_s = max(0, min(l_s, 1)) L_s = l_s * L denominator_h = (np.cos(beta_rad) + (np.sin(beta_rad) * np.cos(gamma_rad) / tan(deg2rad(theta_s)))) if denominator_h == 0: h_s = 0 else: h_s = (1 - (distance * np.sin(beta_rad) + np.cos(beta_rad))) / denominator_h h_s = max(0, min(h_s, 1)) H_s = h_s * H a_s = l_s * h_s return L_s, H_s, a_sdef calcular_sombra_panel(dia, hora, longitud, utc, phi, distance, Lfv, N_s, Hfv, N_p, beta): x = calcular_x(dia, hora) delta = calcular_declination(x) delta_t = calcular_delta_t(x) t_solar = calcular_t_solar(delta_t, longitud, utc) theta_s, sin_theta = calcular_elevacion_sol(t_solar, delta, phi)
if theta_s <= 0: return 0, 0, 0 gamma = calcular_gamma(beta, theta_s) if abs(gamma) > 90: return 0, 0, 0 L_s, H_s, a_s = calcular_sombra(distance, Lfv, N_s, Hfv, N_p, beta, gamma, theta_s) return L_s, H_s, a_sFunción principal para determinar la distancia mínima
def determinar_distancia_minima(anual=True, longitud=-3.7038, utc=2, phi=40.4168, Lfv=1.6, N_s=10, Hfv=1.0, N_p=5, beta=30, hora_inicio=6, hora_fin=18, intervalo=1): """ Determina la distancia mínima entre filas de paneles fotovoltaicos para evitar sombras durante todo el año.
Parámetros: - anual: Si es True, analizará todos los días del año. Si False, solo un día específico. - longitud: Longitud geográfica en grados. - utc: Hora estándar del meridiano (por ejemplo, 2 para GMT+2). - phi: Latitud geográfica en grados. - Lfv: Longitud de un panel fotovoltaico en metros. - N_s: Número de paneles en serie. - Hfv: Altura de un panel fotovoltaico en metros. - N_p: Número de paneles en paralelo. - beta: Ángulo de inclinación del panel en grados. - hora_inicio: Hora de inicio para el cálculo (default 6 AM). - hora_fin: Hora de fin para el cálculo (default 6 PM). - intervalo: Intervalo de tiempo en horas (default 1 hora). Retorna: - distancia_minima: Distancia mínima entre filas en metros. - dia_max: Día del año donde se produjo la máxima sombra. - hora_max: Hora del día donde se produjo la máxima sombra. - sombra_maxima: Máxima longitud de sombra en metros. """ sombra_maxima_total = 0 dia_max = 0 hora_max = 0 # Define el rango de días if anual: dias = range(1, 366) # 1 a 365 else: dias = [172] # Por defecto, 21 de junio total_iteraciones = len(dias) * int((hora_fin - hora_inicio) / intervalo) + len(dias) iteracion = 0 print("Calculando máxima longitud de sombra...") for dia in dias: for hora in np.arange(hora_inicio, hora_fin + intervalo/2, intervalo): iteracion += 1 # Calcular sombra con distance = 0 para obtener la longitud pura L_s, _, _ = calcular_sombra_panel( dia=dia, hora=hora, longitud=longitud, utc=utc, phi=phi, distance=0, # Inicialmente 0 para calcular solo la sombra Lfv=Lfv, N_s=N_s, Hfv=Hfv, N_p=N_p, beta=beta ) if L_s > sombra_maxima_total: sombra_maxima_total = L_s dia_max = dia hora_max = hora # Añadir un pequeño margen de seguridad (por ejemplo, 10%) margen = 0.10 distancia_minima = sombra_maxima_total * (1 + margen) # Mostrar el día y hora que causan la máxima sombra try: # Intentar determinar la fecha (suponiendo año no bisiesto) fecha_max = datetime.datetime.strptime(f"2023-{dia_max}", "%Y-%j") fecha_str = fecha_max.strftime('%d-%m') except ValueError: # Si el día del año es fuera de rango fecha_str = "Desconocida" print(f"\nMáxima sombra encontrada en el día {dia_max} ({fecha_str}) a las {int(hora_max)}:00 horas.") print(f"Máxima longitud de sombra (sin margen): {sombra_maxima_total:.2f} metros") print(f"Distancia mínima entre filas (con 10% de margen): {distancia_minima:.2f} metros" ) return distancia_minima, dia_max, hora_max, sombra_maxima_totalEjemplo de uso
if name == "main": # Parámetros de entrada longitud = -79.9016 # Longitud utc = -5 phi = 22.43306 # Latitud Lfv = 1.6 # Longitud de un panel en metros N_s = 10 # Número de paneles en serie Hfv = 1.0 # Altura de un panel en metros N_p = 5 # Número de paneles en paralelo beta = 19 # Ángulo de inclinación en grados
# Determinar la distancia mínima considerando todo el año distancia_minima, dia_max, hora_max, sombra_maxima = determinar_distancia_minima( anual=True, longitud=longitud, utc=utc, phi=phi, Lfv=Lfv, N_s=N_s, Hfv=Hfv, N_p=N_p, beta=beta, hora_inicio=6, # Desde las 6 AM hora_fin=18, # Hasta las 6 PM intervalo=1 # Cada hora ) # Imprimir la distancia ideal print(f"\n**Distancia ideal mínima entre filas de paneles: {distancia_minima:.2f} metros**") - Assistant
Entiendo que deseas calcular de forma separada la distancia mínima lateral entre filas de paneles fotovoltaicos basándote en la sombra lateral, sin modificar el cálculo existente de las sombras frontales. A continuación, te proporcionaré una nueva función que realiza este cálculo adicional.
Paso 1: Cálculo del Azimut Solar
Para calcular la sombra lateral, es esencial determinar el ángulo de azimut solar, ya que este define la dirección desde la cual proviene la luz del sol. El azimut solar es el ángulo entre el norte geográfico y la proyección horizontal del sol.
Paso 2: Cálculo de la Sombra Lateral
Una vez obtenido el azimut solar, podemos calcular la longitud de la sombra lateral en función de la altura del panel y el ángulo de elevación solar.
Paso 3: Determinación de la Distancia Mínima Lateral
Finalmente, identificaremos la longitud máxima de la sombra lateral a lo largo del año y añadiremos un margen de seguridad para determinar la distancia mínima lateral entre filas de paneles.
Implementación en Código
A continuación, se presenta el código que realiza estos pasos:
import numpy as np from math import sin, cos, radians, degrees, tan, asin, acos import datetime # Funciones de conversión (ya existentes) def deg2rad(degrees_val): return radians(degrees_val) def rad2deg(radians_val): return degrees(radians_val) # Funciones de cálculo solar (ya existentes) def calcular_x(dia, hora): return (2 * np.pi / 365) * (dia - 1 + ((hora - 12) / 24)) def calcular_declination(x): return (0.006918 - 0.399912 * np.cos(x) + 0.070257 * np.sin(x) - 0.006758 * np.cos(2*x) + 0.000907 * np.sin(2*x) - 0.002697 * np.cos(3*x) + 0.001480 * np.sin(3*x)) def calcular_delta_t(x): return (229.18 * (0.00065 + 0.001868 * np.cos(x) - 0.032077 * np.sin(x) - 0.014615 * np.cos(2*x) - 0.040849 * np.sin(2*x))) def calcular_t_solar(delta_t, longitud, utc): return delta_t - (4 * longitud) + (60 * utc) def calcular_elevacion_sol(t_solar, delta, phi): omega = (t_solar / 4) # cada 4 minutos es un grado omega_rad = deg2rad(omega) phi_rad = deg2rad(phi) sin_theta = (np.cos(omega_rad) * np.cos(delta) * np.cos(phi_rad) + np.sin(delta) * np.sin(phi_rad)) # Asegurarse que sin_theta está en el rango [-1, 1] sin_theta = np.clip(sin_theta, -1, 1) theta_s = asin(sin_theta) # En radianes theta_s_deg = rad2deg(theta_s) return theta_s_deg, sin_theta def calcular_gamma(beta, theta_s): return 90 + beta - theta_s # Función para calcular el Azimut Solar def calcular_azimut_sol(t_solar, delta, phi): omega = t_solar / 4 # equivalente en grados theta_s_rad = deg2rad(calcular_elevacion_sol(t_solar, delta, phi)[0]) delta_rad = delta phi_rad = deg2rad(phi) cos_azimuth = (sin(theta_s_rad) * np.sin(phi_rad) - np.sin(delta_rad)) / (np.cos(theta_s_rad) * np.cos(phi_rad)) # Limitar el valor de cos_azimuth entre -1 y 1 para evitar errores numéricos cos_azimuth = np.clip(cos_azimuth, -1, 1) azimuth_rad = acos(cos_azimuth) azimuth_deg = rad2deg(azimuth_rad) # Determinar si el sol está al este o al oeste if omega > 180: azimuth_deg = 360 - azimuth_deg return azimuth_deg # Nueva función para calcular la sombra lateral def calcular_sombra_lateral(theta_s_deg, azimuth_deg, altura_panel): """ Calcula la longitud de la sombra lateral basada en el ángulo de elevación y el azimut solar. Parámetros: - theta_s_deg: Ángulo de elevación solar en grados. - azimuth_deg: Ángulo de azimut solar en grados. - altura_panel: Altura del panel en metros. Retorna: - sombra_lateral: Longitud de la sombra lateral en metros. """ if theta_s_deg <= 0: return 0 # El sol está por debajo del horizonte theta_s_rad = deg2rad(theta_s_deg) sombra_lateral = altura_panel / tan(theta_s_rad) # Considerar solo la componente lateral de la sombra # Asumiendo que la orientación de las filas es hacia el norte (azimut del panel = 180 grados) # La sombra lateral depende del ángulo de azimut relativo al sur # Si las filas están orientadas al sur (azimut del panel = 180), la sombra lateral está a 90 o 270 grados # Ajusta según la orientación real de las filas # Para simplificar, consideramos la máxima sombra lateral posible return sombra_lateral # Nueva función para determinar la distancia mínima lateral def determinar_distancia_minima_lateral(anual=True, longitud=-3.7038, utc=2, phi=40.4168, altura_panel=1.0, # Altura del panel en metros hora_inicio=6, hora_fin=18, intervalo=1): """ Determina la distancia mínima lateral entre filas de paneles fotovoltaicos para evitar sombras laterales durante todo el año. Parámetros: - anual: Si es True, analizará todos los días del año. Si False, solo un día específico. - longitud: Longitud geográfica en grados. - utc: Hora estándar del meridiano (por ejemplo, 2 para GMT+2). - phi: Latitud geográfica en grados. - altura_panel: Altura de un panel en metros. - hora_inicio: Hora de inicio para el cálculo (default 6 AM). - hora_fin: Hora de fin para el cálculo (default 6 PM). - intervalo: Intervalo de tiempo en horas (default 1 hora). Retorna: - distancia_minima_lateral: Distancia mínima lateral entre filas en metros. - dia_max_lateral: Día del año donde se produjo la máxima sombra lateral. - hora_max_lateral: Hora del día donde se produjo la máxima sombra lateral. - sombra_lateral_maxima: Máxima longitud de sombra lateral en metros. """ sombra_lateral_maxima = 0 dia_max_lateral = 0 hora_max_lateral = 0 # Define el rango de días if anual: dias = range(1, 366) # 1 a 365 else: dias = [172] # Por defecto, 21 de junio print("\nCalculando máxima longitud de sombra lateral...") for dia in dias: for hora in np.arange(hora_inicio, hora_fin + intervalo/2, intervalo): # Cálculos solares x = calcular_x(dia, hora) delta = calcular_declination(x) delta_t = calcular_delta_t(x) t_solar = calcular_t_solar(delta_t, longitud, utc) theta_s, sin_theta = calcular_elevacion_sol(t_solar, delta, phi) if theta_s <= 0: continue # Sol por debajo del horizonte azimuth = calcular_azimut_sol(t_solar, delta, phi) sombra_lateral = calcular_sombra_lateral(theta_s, azimuth, altura_panel) if sombra_lateral > sombra_lateral_maxima: sombra_lateral_maxima = sombra_lateral dia_max_lateral = dia hora_max_lateral = hora # Añadir un pequeño margen de seguridad (por ejemplo, 10%) margen = 0.10 distancia_minima_lateral = sombra_lateral_maxima * (1 + margen) # Mostrar el día y hora que causan la máxima sombra lateral try: # Intentar determinar la fecha (suponiendo año no bisiesto) fecha_max = datetime.datetime.strptime(f"2023-{dia_max_lateral}", "%Y-%j") fecha_str = fecha_max.strftime('%d-%m') except ValueError: # Si el día del año es fuera de rango fecha_str = "Desconocida" print(f"\nMáxima sombra lateral encontrada en el día {dia_max_lateral} ({fecha_str}) a las {int(hora_max_lateral)}:00 horas.") print(f"Máxima longitud de sombra lateral (sin margen): {sombra_lateral_maxima:.2f} metros") print(f"Distancia mínima lateral entre filas (con 10% de margen): {distancia_minima_lateral:.2f} metros") return distancia_minima_lateral, dia_max_lateral, hora_max_lateral, sombra_lateral_maxima # Ejemplo de uso if __name__ == "__main__": # Parámetros de entrada para la distancia mínima frontal (existente) longitud = -79.9016 # Longitud utc = -5 phi = 22.43306 # Latitud Lfv = 1.6 # Longitud de un panel en metros N_s = 10 # Número de paneles en serie Hfv = 1.0 # Altura de un panel en metros N_p = 5 # Número de paneles en paralelo beta = 19 # Ángulo de inclinación en grados # Determinar la distancia mínima frontal considerando todo el año distancia_minima, dia_max, hora_max, sombra_maxima = determinar_distancia_minima( anual=True, longitud=longitud, utc=utc, phi=phi, Lfv=Lfv, N_s=N_s, Hfv=Hfv, N_p=N_p, beta=beta, hora_inicio=6, # Desde las 6 AM hora_fin=18, # Hasta las 6 PM intervalo=1 # Cada hora ) # Imprimir la distancia frontal ideal print(f"\n**Distancia ideal mínima entre filas de paneles (frontal): {distancia_minima:.2f} metros**") # Parámetros adicionales para la distancia lateral altura_panel = Hfv # Puede variar según la configuración # Determinar la distancia mínima lateral considerando todo el año distancia_minima_lateral, dia_max_lateral, hora_max_lateral, sombra_lateral_maxima = determinar_distancia_minima_lateral( anual=True, longitud=longitud, utc=utc, phi=phi, altura_panel=altura_panel, hora_inicio=6, # Desde las 6 AM hora_fin=18, # Hasta las 6 PM intervalo=1 # Cada hora ) # Imprimir la distancia lateral ideal print(f"\n**Distancia ideal mínima lateral entre filas de paneles: {distancia_minima_lateral:.2f} metros**")Explicación Detallada del Código Adicional
-
Cálculo del Azimut Solar (
calcular_azimut_sol):- Se utiliza el ángulo de elevación solar (
theta_s_deg) y la declinación solar (delta) para determinar el azimut. - Dependiendo de la hora del día, se ajusta el azimut para reflejar si el sol está al este o al oeste.
- Se utiliza el ángulo de elevación solar (
-
Cálculo de la Sombra Lateral (
calcular_sombra_lateral):- Se calcula la longitud de la sombra lateral usando la altura del panel y el ángulo de elevación solar.
- Esta sombra representa la distancia que los paneles en una fila podrían proyectar lateralmente, afectando las filas adyacentes.
-
Determinación de la Distancia Mínima Lateral (
determinar_distancia_minima_lateral):- Se itera sobre todos los días (o un día específico) y horas para encontrar la máxima longitud de sombra lateral a lo largo del año.
- Se añade un margen de seguridad (por ejemplo, 10%) para asegurar que las sombras no interfieran en condiciones extremas.
- Finalmente, se imprime la información relevante sobre cuándo y dónde se produjo la máxima sombra lateral.
Notas Adicionales
-
Orientación de las Filas: Este cálculo asume que las filas de paneles están orientadas hacia el norte. Si tu configuración es diferente, deberás ajustar el cálculo del azimut relativo.
-
Margen de Seguridad: El margen del 10% es un valor sugerido. Dependiendo de tus necesidades específicas, puedes ajustarlo.
-
Optimización del Intervalo de Tiempo: Para una precisión mayor, considera reducir el
intervalode tiempo (por ejemplo, a 0.5 horas). -
Condiciones Climáticas: Este cálculo asume condiciones solares ideales. Factores como nubosidad o contaminación pueden afectar las sombras en la práctica.
Conclusión
Con la implementación de la función
determinar_distancia_minima_lateral, ahora puedes calcular la distancia mínima lateral necesaria entre filas de paneles fotovoltaicos para evitar sombras durante todo el año. Este cálculo complementa el existente de las sombras frontales, proporcionando una planificación más completa para el diseño de tu instalación fotovoltaica. -