Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Mira este código, necesito calcular (hazlo aparte sin tocar el cálculo de la sombra…

  1. 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_theta
    

    def 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_s
    

    def 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_s
    

    Funció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_total
    

    Ejemplo 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**")
    
  2. 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

    1. 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.
    2. 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.
    3. 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 intervalo de 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.