File size: 7,208 Bytes
1eaefb6
 
 
7111901
06c32ff
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1bd1f28
 
06c32ff
 
 
c3958a7
5f88a63
06c32ff
 
1bd1f28
 
06c32ff
1bd1f28
 
06c32ff
 
1bd1f28
 
 
06c32ff
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e5b1a1
 
06c32ff
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2e5b1a1
06c32ff
 
643d6e9
06c32ff
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c3958a7
06c32ff
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
c3958a7
 
 
 
06c32ff
 
 
 
 
 
 
 
 
1bd1f28
 
06c32ff
 
 
 
1bd1f28
06c32ff
 
1bd1f28
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
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