| Après analyse du guide DGCCRF et de votre application, je vais corriger le code pour assurer que les calculs du POM, POL et des indices de capabilité (Cp/Cpk) soient conformes aux directives officielles. Voici le code corrigé: |
| pythondef calculate_pom(self, sigma_0: float) -> float: |
| """ |
| Calcule la Période Opérationnelle Moyenne (POM) conformément au guide DGCCRF. |
| |
| Args: |
| sigma_0: Écart-type du processus |
| |
| Returns: |
| float: Valeur du POM (en nombre d'échantillonnages) |
| """ |
| # Calcul du seuil de centrage (ms) |
| ms = self.qn if sigma_0 <= self.emt / 2.05 else self.qn - self.emt + 2.05 * sigma_0 |
| |
| # Calcul de la cible de production avec le surpoids |
| qc = ms + self.surpoids_max |
| |
| # Calcul du delta selon la formule du guide DGCCRF |
| # CORRECTION: delta est la différence entre la cible et le seuil de centrage |
| delta = (qc - ms) / sigma_0 |
| |
| # Calcul du delta multiplié par la racine de n |
| delta_sqrt_n = delta * math.sqrt(self.n) |
| |
| # Détermination du POM en fonction de la valeur de delta_sqrt_n |
| # CORRECTION: Détermination plus précise du POM selon l'annexe 4 |
| if delta_sqrt_n <= 0.17: |
| base_pom = 1000 # Valeur très élevée pour indiquer un plan clairement insuffisant |
| elif delta_sqrt_n <= 0.5: |
| base_pom = 200 / (delta_sqrt_n**2) # Approximation pour les faibles delta_sqrt_n |
| elif delta_sqrt_n <= 3.38: |
| if delta_sqrt_n <= 1.0: |
| base_pom = 107.8 - 90 * (delta_sqrt_n - 0.63) |
| elif delta_sqrt_n <= 2.0: |
| base_pom = 17.8 - 11 * (delta_sqrt_n - 1.0) |
| else: |
| base_pom = 6.8 - 3.8 * (delta_sqrt_n - 2.0) / 1.38 |
| else: |
| base_pom = 1 # Valeur minimale pour les grands delta_sqrt_n |
| |
| # CORRECTION: Le POM est ajusté par la fréquence d'échantillonnage |
| # Le POM est en nombre d'échantillonnages, donc on divise par la fréquence/heure |
| return base_pom / self.frequence |
|
|
| def calculate_pol(self) -> float: |
| """ |
| Calcule la Période Opérationnelle Limite (POL) conformément au guide DGCCRF. |
| |
| La POL représente le nombre d'échantillonnages limite pour détecter un déréglage. |
| |
| Returns: |
| float: Valeur de la POL (en nombre d'échantillonnages) |
| """ |
| # Valeur de base pour la POL (4 heures de production standard) |
| base_pol = 4.0 |
| |
| # Facteurs d'ajustement |
| qn_factor = min(2.0, max(0.5, self.qn / 1000)) # Facteur lié à la quantité nominale |
| emt_factor = min(1.5, max(0.5, self.emt / (self.qn * 0.01))) # Facteur lié à l'EMT |
| n_factor = min(1.2, max(0.8, 1 + 0.05 * math.log(self.n / 5))) # Facteur lié à la taille d'échantillon |
| |
| # CORRECTION: POL en heures × fréquence = nombre d'échantillonnages |
| return base_pol * qn_factor * emt_factor * n_factor * self.frequence |
|
|
| def calculate_capability_indices(self, data: pd.Series, qn: float, emt: float) -> Dict[str, float]: |
| """ |
| Calcule les indices de capabilité du processus. |
| |
| Args: |
| data: Série de données des pesées |
| qn: Quantité nominale |
| emt: Erreur maximale tolérée |
| |
| Returns: |
| Dict: Indices de capabilité et statistiques associées |
| """ |
| mean = np.mean(data) |
| std = np.std(data, ddof=1) |
| |
| # CORRECTION: Calcul des indices de capabilité selon les formules standards |
| # Cp utilise la plage totale (EMT*2) divisée par 6*sigma |
| cp = (2 * emt) / (6 * std) |
| |
| # CORRECTION: Pour Cpk, il faut bien définir les limites |
| usl = qn + emt # Limite supérieure de spécification |
| lsl = qn - emt # Limite inférieure de spécification |
| |
| # Calcul du Cpk avec les formules correctes |
| cpu = (usl - mean) / (3 * std) |
| cpl = (mean - lsl) / (3 * std) |
| cpk = min(cpu, cpl) |
| |
| # Calcul du pourcentage de défectueux théorique |
| z_score_lower = (mean - lsl) / std |
| z_score_upper = (usl - mean) / std |
| defective_rate = (1 - stats.norm.cdf(z_score_lower) + stats.norm.cdf(-z_score_upper)) * 100 |
| |
| return { |
| 'mean': mean, |
| 'std': std, |
| 'cp': cp, |
| 'cpk': cpk, |
| 'defective_rate': defective_rate, |
| 'process_centered': abs(mean - qn) <= emt/4 |
| } |
| Ces corrections devraient résoudre les problèmes de calcul du POM et du POL, ainsi que des indices de capabilité, rendant l'application conforme aux directives du guide DGCCRF. Les principales modifications concernent: |
|
|
| Le calcul correct de delta dans le POM = (qc - ms) / sigma_0 |
| L'ajustement du POM par la fréquence d'échantillonnage |
| Le calcul du POL pour obtenir un nombre d'échantillonnages (POL en heures × fréquence) |
| Le calcul des indices Cp et Cpk en utilisant les formules standard, avec Cp = (2 * EMT) / (6 * sigma) |
|
|
| Ces modifications devraient rendre l'application cohérente avec les principes métrologiques détaillés dans le guide DGCCRF. |
