Spaces:
Sleeping
Sleeping
Download app/error_bar_utils.py from ClementGERARD/Polyfit: direct link, hf CLI and curl.
- Browser
- Download file 7.21 kB
-
https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/main/app/error_bar_utils.py
- Command line
-
hf download hf://spaces/ClementGERARD/Polyfit/app/error_bar_utils.py
-
curl -L -o error_bar_utils.py https://huggingface.co/spaces/ClementGERARD/Polyfit/resolve/main/app/error_bar_utils.py
7.21 kB
| import numpy as np | |
| from pvlib.pvsystem import i_from_v | |
| def get_parameter_error_bounds(I, V, Rs, Rsh, n, J0, Jph, condition_initiale=1e-7, | |
| facteur_adaptation=10, max_tentatives=3): | |
| """ | |
| Fonction améliorée pour calculer les bornes d'erreur des paramètres d'un modèle photovoltaïque. | |
| Paramètres: | |
| ----------- | |
| I, V : array-like | |
| Courants et tensions mesurés | |
| Rs, Rsh, n, J0, Jph : float | |
| Paramètres initiaux du modèle | |
| condition_initiale : float, optional | |
| Seuil initial pour la sélection des paramètres intéressants | |
| facteur_adaptation : float, optional | |
| Facteur par lequel multiplier la condition si aucun paramètre n'est trouvé | |
| max_tentatives : int, optional | |
| Nombre maximal de tentatives d'adaptation de la condition | |
| Retourne: | |
| --------- | |
| dictionnaire_bornes : dict | |
| Dictionnaire contenant les bornes min et max pour chaque paramètre | |
| """ | |
| k = 1.3806503e-23 # Boltzmann constant (J/K) | |
| q = 1.60217646e-19 # Elementary charge (C) | |
| Tmes = 25 + 273.15 | |
| Vth = k * Tmes / q | |
| condition = condition_initiale | |
| def generer_bruit_unique(valeur, n=4000, pourcentage=0.0035): | |
| valeurs = [] | |
| for h in range(0, n): | |
| valeurs.append(valeur) | |
| signal = np.array(valeurs) | |
| bruit = np.random.normal(0, valeur*pourcentage, size=signal.shape) | |
| signal_bruité = list(signal + bruit) | |
| return signal_bruité | |
| # Génération des valeurs bruitées | |
| Rs_bruité1 = generer_bruit_unique(Rs) | |
| n_bruité1 = generer_bruit_unique(n) | |
| J0_bruité1 = generer_bruit_unique(J0) | |
| Rsh_bruité1 = generer_bruit_unique(Rsh) | |
| # Ajout des valeurs originales au début | |
| Rs_bruité1.insert(0, Rs) | |
| n_bruité1.insert(0, n) | |
| J0_bruité1.insert(0, J0) | |
| Rsh_bruité1.insert(0, Rsh) | |
| Rs_bruité = [Rs_bruité1] | |
| n_bruité = [n_bruité1] | |
| J0_bruité = [J0_bruité1] | |
| Rsh_bruité = [Rsh_bruité1] | |
| # Fonction pour calculer chi2 et collecter les paramètres intéressants | |
| def chi2_général(V, I, Jph, Rsh_bruité, J0_bruité, Rs_bruité, n_bruité, j, condition): | |
| n_intéressants = [] | |
| J0_intéressants = [] | |
| Rs_intéressants = [] | |
| Rsh_intéressants = [] | |
| chi2_values = [] # Pour stocker toutes les valeurs de chi2 | |
| try: | |
| I_bruite_j = i_from_v(V, Jph, J0_bruité[0][j], Rs_bruité[0][j], Rsh_bruité[0][j], n_bruité[0][j]*Vth) | |
| # Vérification de validité physique | |
| if not isinstance(I_bruite_j, np.ndarray) or np.isnan(I_bruite_j).any(): | |
| print(f"Résultat non valide pour j={j}") | |
| return n_intéressants, J0_intéressants, Rs_intéressants, Rsh_intéressants, chi2_values | |
| I_bruite_j = np.array(I_bruite_j) | |
| # Méthode améliorée pour déterminer si une inversion est nécessaire | |
| # Calculer la corrélation entre I et I_bruite_j | |
| correlation = np.corrcoef(I, I_bruite_j)[0, 1] | |
| if correlation < 0: # Si corrélation négative, inverser | |
| I_bruite_j = -I_bruite_j | |
| chi21 = np.sum((I_bruite_j - I) ** 2) | |
| chi2_values.append(chi21) | |
| if chi21 < condition: | |
| n_intéressants.append(n_bruité[0][j]) | |
| J0_intéressants.append(J0_bruité[0][j]) | |
| Rs_intéressants.append(Rs_bruité[0][j]) | |
| Rsh_intéressants.append(Rsh_bruité[0][j]) | |
| except Exception as e: | |
| print(f"Erreur à l'étape j={j} avec paramètres: Rs={Rs_bruité[0][j]}, n={n_bruité[0][j]}, " | |
| f"J0={J0_bruité[0][j]}, Rsh={Rsh_bruité[0][j]}: {e}") | |
| return n_intéressants, J0_intéressants, Rs_intéressants, Rsh_intéressants, chi2_values | |
| # Boucle d'adaptation de la condition | |
| tentative = 0 | |
| tous_chi2 = [] | |
| while tentative < max_tentatives: | |
| n_intéressants = [] | |
| J0_intéressants = [] | |
| Rs_intéressants = [] | |
| Rsh_intéressants = [] | |
| for j in range(len(Rs_bruité[0])): | |
| n_int, J0_int, Rs_int, Rsh_int, chi2_vals = chi2_général( | |
| V, I, Jph, Rsh_bruité, J0_bruité, Rs_bruité, n_bruité, j, condition) | |
| n_intéressants.extend(n_int) | |
| J0_intéressants.extend(J0_int) | |
| Rs_intéressants.extend(Rs_int) | |
| Rsh_intéressants.extend(Rsh_int) | |
| tous_chi2.extend(chi2_vals) | |
| # Si on a trouvé assez de paramètres intéressants, on sort de la boucle | |
| if len(n_intéressants) >= 4: # Seuil arbitraire, à ajuster | |
| print(f"Condition adaptée à {condition}, {len(n_intéressants)} paramètres trouvés") | |
| break | |
| # Sinon, on relâche la condition et on réessaie | |
| condition *= facteur_adaptation | |
| print(f"Adaptation de la condition à {condition}") | |
| tentative += 1 | |
| # Si après toutes les tentatives on n'a toujours pas de paramètres intéressants | |
| if not n_intéressants: | |
| print("Aucun paramètre intéressant trouvé même après adaptation de la condition") | |
| print(f"Chi2 min: {min(tous_chi2) if tous_chi2 else 'N/A'}, " | |
| f"Chi2 max: {max(tous_chi2) if tous_chi2 else 'N/A'}") | |
| # Utiliser les paramètres originaux comme valeurs centrales | |
| Rs_central, n_central, J0_central, Rsh_central = Rs, n, J0, Rsh | |
| # Calculer des bornes basées sur la distribution des paramètres testés | |
| if len(Rs_bruité[0]) > 1: | |
| Rs_min, Rs_max = min(Rs_bruité[0]), max(Rs_bruité[0]) | |
| n_min, n_max = min(n_bruité[0]), max(n_bruité[0]) | |
| J0_min, J0_max = min(J0_bruité[0]), max(J0_bruité[0]) | |
| Rsh_min, Rsh_max = min(Rsh_bruité[0]), max(Rsh_bruité[0]) | |
| else: | |
| # Fallback si même les paramètres bruités ne sont pas disponibles | |
| Rs_min, Rs_max = 0.9*Rs, 1.1*Rs | |
| n_min, n_max = 0.9*n, 1.1*n | |
| J0_min, J0_max = 0.9*J0, 1.1*J0 | |
| Rsh_min, Rsh_max = 0.9*Rsh, 1.1*Rsh | |
| else: | |
| # Calcul normal des bornes avec les paramètres intéressants trouvés | |
| Rs_central = Rs_intéressants[0] | |
| n_central = n_intéressants[0] | |
| J0_central = J0_intéressants[0] | |
| Rsh_central = Rsh_intéressants[0] | |
| Rs_min = min(Rs_intéressants) | |
| Rs_max = max(Rs_intéressants) | |
| n_min = min(n_intéressants) | |
| n_max = max(n_intéressants) | |
| J0_min = min(J0_intéressants) | |
| J0_max = max(J0_intéressants) | |
| Rsh_min = min(Rsh_intéressants) | |
| Rsh_max = max(Rsh_intéressants) | |
| dictionnaire_bornes = { | |
| 'Rs': {'min': Rs_min, 'max': Rs_max, 'central': Rs_central}, | |
| 'n': {'min': n_min, 'max': n_max, 'central': n_central}, | |
| 'J0': {'min': J0_min, 'max': J0_max, 'central': J0_central}, | |
| 'Rsh': {'min': Rsh_min, 'max': Rsh_max, 'central': Rsh_central} | |
| } | |
| return dictionnaire_bornes | |