Update app.py

app.py

@@ -735,116 +735,145 @@ class NutrientCalculator:
         self.target_profile = BASE_PROFILE.copy()
         self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
         self.total_ec = 0.0
+        self.best_solution = None
+        self.min_difference = float('inf')
+        self.max_recursion_depth = 1000  # Ограничение глубины рекурсии
+        self.current_depth = 0
+        self.fertilizer_list = list(self.fertilizers.keys())
 
         # Расчёт азота
         total_parts = NO3_RATIO + NH4_RATIO
         self.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / total_parts)
         self.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / total_parts)
 
-        # Сохраняем исходный профиль азота
-        self.initial_n_profile = {
-            "NO3-": self.target_profile['N (NO3-)'],
-            "NH4+": self.target_profile['N (NH4+)']
-        }
-
-        # Список всех удобрений
-        self.fertilizer_list = list(self.fertilizers.keys())
-
     def calculate(self):
         try:
-            # Инициализация фактического профиля и результата
             self.actual_profile = {k: 0.0 for k in self.target_profile}
             self.results = {}
-
-            # Начинаем рекурсивный поиск
+            self.current_depth = 0
+            
             if self._backtrack_search():
-                print("Успешная комбинация найдена!")
-                return self.results
+                print("Оптимальная комбинация найдена!")
+                return self.best_solution
             else:
-                raise ValueError("Не удалось найти подходящую комбинацию удобрений.")
+                return self.best_solution or {"error": "Не удалось найти идеальную комбинацию"}
 
         except Exception as e:
             print(f"Ошибка при расчёте: {str(e)}")
             raise
 
-    def _backtrack_search(self, fertilizer_index=0):
-        """Рекурсивный поиск с возвратом"""
-        # Проверяем, достигнуты ли целевые значения
-        if self.validate_results():
-            return True
+    def _backtrack_search(self, fertilizer_index=0, step=1.0):
+        self.current_depth += 1
+        if self.current_depth > self.max_recursion_depth:
+            return False
+
+        # Проверяем текущее решение
+        current_diff = self._calculate_difference()
+        if current_diff < self.min_difference:
+            self.min_difference = current_diff
+            self.best_solution = {
+                "results": self._copy_results(),
+                "actual_profile": self.actual_profile.copy(),
+                "total_ec": self.total_ec,
+                "difference": current_diff
+            }
+            
+            if current_diff < 0.1:  # Допустимая погрешность
+                return True
 
-        # Пробуем добавить удобрения по очереди
+        # Пробуем добавлять удобрения с текущего индекса
         for i in range(fertilizer_index, len(self.fertilizer_list)):
             fert_name = self.fertilizer_list[i]
-
-            # Применяем удобрение
-            if self._can_apply_fertilizer(fert_name):
-                self._apply_fertilizer(fert_name)
-                print(f"Добавлено удобрение: {fert_name}")
-
-                # Рекурсивно пробуем следующее удобрение
-                if self._backtrack_search(i + 1):
+            
+            # Проверяем, можно ли применить удобрение
+            if not self._can_apply_fertilizer(fert_name):
+                continue
+            
+            # Пробуем добавить удобрение с текущим шагом
+            self._apply_fertilizer(fert_name, step)
+            
+            # Рекурсивно продолжаем поиск
+            if self._backtrack_search(i, step):
+                return True
+                
+            # Если не получилось - откатываемся
+            self._remove_fertilizer(fert_name, step)
+            
+            # Пробуем уменьшить шаг для более точного поиска
+            if step > 0.1 and current_diff > 1.0:
+                if self._backtrack_search(i, step / 2):
                     return True
 
-                # Откатываемся назад (удаляем последнее удобрение)
-                self._remove_fertilizer(fert_name)
-                print(f"Откат: удалено удобрение {fert_name}")
-
         return False
 
     def _can_apply_fertilizer(self, fert_name):
-        """Провер��а, можно ли применить удобрение без перебора"""
+        """Проверяет, можно ли применить удобрение без перебора"""
         for element, content in self.fertilizers[fert_name].items():
-            added_ppm = (1 * content * 1000) / self.volume  # Добавляем 1 грамм для проверки
+            added_ppm = (1 * content * 1000) / self.volume
             if self.actual_profile[element] + added_ppm > self.target_profile[element] + 0.1:
                 return False
         return True
 
-    def _apply_fertilizer(self, fert_name):
-        """Применение удобрения"""
+    def _apply_fertilizer(self, fert_name, amount):
+        """Добавляет указанное количество удобрения"""
         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'внесет {elem}'] = 0.0
-
-        # Находим минимальный недостаток среди всех элементов удобрения
-        min_required_ppm = float('inf')
-        for element, content in self.fertilizers[fert_name].items():
-            required_ppm = self.target_profile[element] - self.actual_profile[element]
-            if required_ppm > 0.1:
-                min_required_ppm = min(min_required_ppm, required_ppm / content)
-
-        # Добавляем удобрение в количестве, необходимом для покрытия минимального недостатка
-        grams = min_required_ppm * 1000
-        self.results[fert_name]['граммы'] += grams
-        self.results[fert_name]['миллиграммы'] += int(grams * 1000)
-
+            self._init_fertilizer_record(fert_name)
+            
+        self.results[fert_name]['граммы'] += amount
+        self.results[fert_name]['миллиграммы'] += int(amount * 1000)
+        
+        added_ec = 0.0
         for element, content in self.fertilizers[fert_name].items():
-            added_ppm = (grams * content * 1000) / self.volume
+            added_ppm = (amount * content * 1000) / self.volume
             self.results[fert_name][f'внесет {element}'] += added_ppm
             self.actual_profile[element] += added_ppm
+            added_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
+            
+        self.results[fert_name]['вклад в EC'] += added_ec
+        self.total_ec += added_ec
 
-    def _remove_fertilizer(self, fert_name):
-        """Удаление удобрения"""
+    def _remove_fertilizer(self, fert_name, amount):
+        """Удаляет указанное количество удобрения"""
         if fert_name in self.results:
-            grams = self.results[fert_name]['граммы']
+            self.results[fert_name]['граммы'] -= amount
+            self.results[fert_name]['миллиграммы'] -= int(amount * 1000)
+            
+            removed_ec = 0.0
             for element, content in self.fertilizers[fert_name].items():
-                added_ppm = (grams * content * 1000) / self.volume
-                self.actual_profile[element] -= added_ppm
-            del self.results[fert_name]
-
-    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
+                removed_ppm = (amount * content * 1000) / self.volume
+                self.results[fert_name][f'внесет {element}'] -= removed_ppm
+                self.actual_profile[element] -= removed_ppm
+                removed_ec += removed_ppm * EC_COEFFICIENTS.get(element, 0.0015)
+                
+            self.results[fert_name]['вклад в EC'] -= removed_ec
+            self.total_ec -= removed_ec
+            
+            if self.results[fert_name]['граммы'] <= 0.001:
+                del self.results[fert_name]
+
+    def _calculate_difference(self):
+        """Вычисляет общее отклонение от целевого профиля"""
+        return sum(
+            abs(self.actual_profile[e] - self.target_profile[e])
+            for e in self.target_profile
+        )
+
+    def _copy_results(self):
+        """Создаёт глубокую копию результатов"""
+        return {
+            fert: data.copy()
+            for fert, data in self.results.items()
+        }
+
+    def _init_fertilizer_record(self, fert_name):
+        """Инициализирует запись для нового удобрения"""
+        self.results[fert_name] = {
+            'граммы': 0.0,
+            'миллиграммы': 0,
+            'вклад в EC': 0.0
+        }
+        for elem in self.fertilizers[fert_name]:
+            self.results[fert_name][f'внесет {elem}'] = 0.0
 
     def calculate_ec(self):
         return round(self.total_ec, 2)