import numpy as np

# Constantes físicas fundamentales
q = 1.602e-19    # Carga elemental del electrón (Coulombs)
k = 1.381e-23    # Constante de Boltzmann (Joules/Kelvin)

# Función para ajustar parámetros según condiciones ambientales
def ajustar_parametros(Jsc_ref, Voc_ref, G, T_cell, T_ref=25):
    """
    Ajusta los parámetros fotovoltaicos a las condiciones reales de operación
    Jsc_ref: Corriente de cortocircuito de referencia [mA/cm²]
    Voc_ref: Voltaje de circuito abierto de referencia [V]
    G: Irradiancia real [W/m²]
    T_cell: Temperatura de la celda [°C]
    T_ref: Temperatura de referencia (STC) [°C]
    """
    alpha = 0.0006  # Coeficiente de temperatura para Jsc (1/°C)
    beta = -0.0021  # Coeficiente de temperatura para Voc (V/°C)
    G_ref = 1000    # Irradiancia de referencia STC [W/m²]
    
    # Convertir temperatura a Kelvin para cálculos físicos
    T_kelvin = T_cell + 273.15
    
    # Ajustar Jsc: depende de irradiancia y temperatura
    Jsc = [J * (G / G_ref) * (1 + alpha * (T_cell - T_ref)) for J in Jsc_ref]
    
    # Ajustar Voc: depende principalmente de temperatura
    Voc = [V + beta * (T_cell - T_ref) for V in Voc_ref]
    
    return Jsc, Voc, T_kelvin

# Función para calcular la corriente del panel
def calc_current(V, Jsc, J0, n, T):
    """
    Calcula la corriente para un voltaje dado en configuración serie
    V: Voltaje aplicado [V]
    Jsc: Corriente de cortocircuito ajustada [mA/cm²]
    J0: Corriente de saturación [mA/cm²]
    n: Factor de idealidad [adimensional]
    T: Temperatura en Kelvin [K]
    """
    # Distribuir voltaje equitativamente entre las 3 uniones
    Vj = V / 3
    
    # Calcular corriente para cada unión usando modelo del diodo
    I1 = Jsc[0] - J0[0] * (np.exp(q * Vj / (n[0] * k * T)) - 1)
    I2 = Jsc[1] - J0[1] * (np.exp(q * Vj / (n[1] * k * T)) - 1)
    I3 = Jsc[2] - J0[2] * (np.exp(q * Vj / (n[2] * k * T)) - 1)
    
    # La corriente está limitada por la unión que genera menos corriente
    return min(I1, I2, I3)

# ===== PARÁMETROS DE ENTRADA =====
T_cell = 25.16        # Temperatura de operación (°C)
G = 3370.63
# Irradiancia (W/m²)
n_celdas = 1000    # Número de celdas en el panel

# Parámetros de la celda de triple unión en STC
Jsc_ref = [12.0, 11.5, 11.0]  # mA/cm² (por unión)
Voc_ref = [0.87, 0.85, 0.81]   # V (por unión)
J0 = [1e-10, 5e-10, 1e-9]      # mA/cm² (convertido a unidades consistentes)
n = [1.2, 1.3, 1.4]            # Factores de idealidad

# ===== CÁLCULOS PRINCIPALES =====
# 1. Ajustar parámetros a condiciones reales
Jsc, Voc, T_K = ajustar_parametros(Jsc_ref, Voc_ref, G, T_cell)

# 2. Calcular voltaje máximo posible (suma de Voc de uniones)
V_max = sum(Voc)

# 3. Crear rango de voltajes para evaluar (0 a V_max)
voltajes = np.linspace(0, V_max, 500)

# 4. Calcular corriente para cada voltaje
corrientes = [calc_current(V, Jsc, J0, n, T_K) for V in voltajes]

# 5. Calcular potencia instantánea (V*I)
#    Considerando área total del panel:
area_celda_cm2 = 3.0 * 4.0            # Área por celda (cm²)
area_total_cm2 = n_celdas * area_celda_cm2  # Área total (cm²)
potencias = [V * I * area_total_cm2 / 1000 for V, I in zip(voltajes, corrientes)]  # Convertir a Watts

# 6. Encontrar potencia máxima (MPP)
Pmax = max(potencias)
idx = np.argmax(potencias)
V_mpp = voltajes[idx]
I_mpp = corrientes[idx]

# ===== RESULTADOS =====
print("\n" + "="*50)
print(f"*** POTENCIA MÁXIMA DEL PANEL SOLAR ***")
print("="*50)
print(f"- Temperatura operación: {T_cell} °C")
print(f"- Irradiancia: {G} W/m²")
print(f"- Celdas en panel: {n_celdas}")
print(f"- Área total: {area_total_cm2/10000:.2f} m²")
print("\n" + "-"*50)
print(f"Tensión en MPP: {V_mpp:.3f} V")
print(f"Corriente en MPP: {I_mpp:.3f} mA/cm²")
print(f"POTENCIA MÁXIMA: {Pmax:.3f} W")
print("="*50)