Update app.py

app.py

@@ -767,86 +767,70 @@ class NutrientCalculator:
 
     def calculate(self):
         try:
-            # Первый проход: компенсация основных элементов
-            self._compensate_main_elements()
+            max_iterations = 100  # Максимальное количество итераций
+            iteration = 0
+            while iteration < max_iterations:
+                iteration += 1
+                print(f"Итерация {iteration} из {max_iterations}")
 
-            # Второй проход: компенсация азота
-            self._compensate_nitrogen()
+                # Сброс фактического профиля
+                self._reset_actual_profile()
 
-            # Третий проход: компенсация второстепенных элементов
-            self._compensate_secondary_elements()
+                # Применение удобрений
+                self._apply_fertilizers()
 
-            # Четвертый проход: корректировка перебора
-            self._adjust_overages()
+                # Проверка результатов
+                if self.validate_results():
+                    print("Успешная комбинация найдена!")
+                    return self.results
+
+                # Корректировка перебора
+                self._adjust_overages()
+
+            raise ValueError("Не удалось найти подходящую комбинацию удобрений после максимального количества итераций.")
 
-            return self.results
         except Exception as e:
             print(f"Ошибка при расчёте: {str(e)}")
             raise
 
-    def _compensate_main_elements(self):
-        """Компенсация основных элементов (Ca, Mg, P)"""
-        for element, weight_data in self.compensation_weights.items():
-            if element in ["Ca", "Mg", "P"]:
-                fert_name = weight_data["fert"]
-                main_element = weight_data["main_element"]
-                required_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
-                if required_ppm > 0.1:
-                    self._apply_with_limit(fert_name, main_element, required_ppm)
-
-    def _compensate_nitrogen(self):
-        """Компенсация азота (NO3-, NH4+)"""
-        for nitrogen_type in ["N (NO3-)", "N (NH4+)"]:
-            required_ppm = self.target_profile[nitrogen_type] - self.actual_profile[nitrogen_type]
-            if required_ppm > 0.1:
-                fert_name = self.compensation_weights[nitrogen_type]["fert"]
-                self._apply_with_limit(fert_name, nitrogen_type, required_ppm)
-
-    def _compensate_secondary_elements(self):
-        """Компенсация второстепенных элементов (K, S)"""
-        for element, weight_data in self.compensation_weights.items():
-            if element in ["K", "S"]:
-                fert_name = weight_data["fert"]
-                main_element = weight_data["main_element"]
-                required_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
+    def _reset_actual_profile(self):
+        """Сброс фактического профиля перед новой итерацией"""
+        self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
+        self.total_ec = 0.0
+        self.results = {}
+
+    def _apply_fertilizers(self):
+        """Применение удобрений"""
+        for fert_name, fert_data in self.fertilizers.items():
+            for element, content in fert_data.items():
+                required_ppm = self.target_profile[element] - self.actual_profile[element]
                 if required_ppm > 0.1:
-                    self._apply_with_limit(fert_name, main_element, required_ppm)
+                    grams = min((required_ppm * self.volume) / (content * 1000), 100)  # Ограничение на граммы
+                    self._apply_with_limit(fert_name, element, grams, content)
+
+    def _apply_with_limit(self, fert_name, element, grams, content):
+        """Применение удобрения с ограничением"""
+        if fert_name not in self.results:
+            self.results[fert_name] = {
+                'граммы': 0.0,
+                'миллиграммы': 0,
+                'вклад в EC': 0.0
+            }
+            for elem in self.fertilizers[fert_name]:
+                self.results[fert_name][f'внесет {self._label(elem)}'] = 0.0
 
-    def _apply_with_limit(self, fert_name, main_element, required_ppm):
-        """Применение удобрения с ограничением по перебору"""
-        if required_ppm <= 0:
-            return
+        self.results[fert_name]['граммы'] += grams
+        self.results[fert_name]['миллиграммы'] += int(grams * 1000)
 
-        try:
-            content = self.fertilizers[fert_name][main_element]
-            max_allowed_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
-            grams = min((required_ppm * self.volume) / (content * 1000), (max_allowed_ppm * self.volume) / (content * 1000))
-
-            if fert_name not in self.results:
-                result = {
-                    'граммы': 0.0,
-                    'миллиграммы': 0,
-                    'вклад в EC': 0.0
-                }
-                for element in self.fertilizers[fert_name]:
-                    result[f'внесет {self._label(element)}'] = 0.0
-                self.results[fert_name] = result
-
-            self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
-
-            fert_ec = 0.0
-            for element, percent in self.fertilizers[fert_name].items():
-                added_ppm = (grams * percent * 1000) / self.volume
-                self.results[fert_name][f'внесет {self._label(element)}'] += added_ppm
-                self.actual_profile[element] += added_ppm
-                fert_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
-
-            self.results[fert_name]['вклад в EC'] += fert_ec
-            self.total_ec += fert_ec
-        except KeyError as e:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
-            raise
+        fert_ec = 0.0
+        for elem, percent in self.fertilizers[fert_name].items():
+            added_ppm = (grams * percent * 1000) / self.volume
+            self.results[fert_name][f'внесет {self._label(elem)}'] += added_ppm
+            self.actual_profile[elem] += added_ppm
+            fert_ec += added_ppm * EC_COEFFICIENTS.get(elem, 0.0015)
+
+        self.results[fert_name]['вклад в EC'] += fert_ec
+        self.total_ec += fert_ec
 
     def _adjust_overages(self):
         """Корректировка перебора элементов"""
@@ -854,45 +838,41 @@ class NutrientCalculator:
             if self.actual_profile[element] > self.target_profile[element]:
                 overage = self.actual_profile[element] - self.target_profile[element]
                 print(f"Корректировка перебора: {element} уменьшен на {overage:.2f} ppm")
-                
+
                 # Уменьшаем фактическое значение
                 self.actual_profile[element] -= overage
-                
+
                 # Обновляем результаты удобрений
                 for fert_name, fert_data in self.results.items():
                     if f'внесет {self._label(element)}' in fert_data:
-                        fert_data[f'внесет {self._label(element)}'] -= overage
-                        
+                        current_value = fert_data[f'внесет {self._label(element)}']
+                        if current_value > overage:
+                            fert_data[f'внесет {self._label(element)}'] -= overage
+                            overage = 0
+                        else:
+                            overage -= current_value
+                            fert_data[f'внесет {self._label(element)}'] = 0
+
                         # Пересчитываем граммы удобрения
                         if element in self.fertilizers[fert_name]:
                             content = self.fertilizers[fert_name][element]
-                            grams_to_remove = (overage * self.volume) / (content * 1000)
+                            grams_to_remove = (current_value * self.volume) / (content * 1000)
                             fert_data['граммы'] -= grams_to_remove
                             fert_data['миллиграммы'] -= int(grams_to_remove * 1000)
 
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
-
-    def print_initial_nitrogen_report(self):
-        try:
-            print("Исходный расчёт азота:")
-            print(f"  NO3-: {self.initial_n_profile['NO3-']} ppm")
-            print(f"  NH4+: {self.initial_n_profile['NH4+']} ppm")
-        except Exception as e:
-            print(f"Ошибка при выводе отчёта: {str(e)}")
-            raise
-
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
-
-    def print_initial_nitrogen_report(self):
-        try:
-            print("Исходный расчёт азота:")
-            print(f"  NO3-: {self.initial_n_profile['NO3-']} ppm")
-            print(f"  NH4+: {self.initial_n_profile['NH4+']} ppm")
-        except Exception as e:
-            print(f"Ошибка при выводе отчёта: {str(e)}")
-            raise
+                        # Убеждаемся, что граммы не отрицательны
+                        if fert_data['граммы'] < 0:
+                            fert_data['граммы'] = 0
+                            fert_data['миллиграммы'] = 0
+
+    def validate_results(self):
+        """Проверка соответствия целевым значениям"""
+        for element, target_value in self.target_profile.items():
+            actual_value = self.actual_profile[element]
+            if abs(actual_value - target_value) > 0.1:  # Допустимая погрешность
+                print(f"Несоответствие: {element} (цель: {target_value:.2f}, фактически: {actual_value:.2f})")
+                return False
+        return True
 
     def calculate_ec(self):
         return round(self.total_ec, 2)