Update app.py

app.py

@@ -735,132 +735,116 @@ 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
 
         # Расчёт азота
         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.best_solution
+                print("Успешная комбинация найдена!")
+                return self.results
             else:
-                return self.best_solution or {"error": "Не удалось найти идеальную комбинацию"}
+                raise ValueError("Не удалось найти подходящую комбинацию удобрений.")
 
         except Exception as e:
             print(f"Ошибка при расчёте: {str(e)}")
             raise
 
-    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
+    def _backtrack_search(self, fertilizer_index=0):
+        """Рекурсивный поиск с возвратом"""
+        # Проверяем, достигнуты ли целевые значения
+        if self.validate_results():
+            return True
 
-        # Пробуем добавлять удобрения с текущего индекса
+        # Пробуем добавить удобрения по очереди
         for i in range(fertilizer_index, len(self.fertilizer_list)):
             fert_name = self.fertilizer_list[i]
-            
-            # Пробуем добавить удобрение с текущим шагом
-            self._apply_fertilizer(fert_name, step)
-            
-            # Рекурсивно продолжаем поиск
-            if self._backtrack_search(i, step):
-                return True
-                
-            # Если не получилось - откатываемся
-            self._remove_fertilizer(fert_name, step)
-            
-            # Пробуем уменьшить шаг для более точного поиска
-            if step > 0.1:
-                if self._backtrack_search(i, step/2):
+
+            # Применяем удобрение
+            if self._can_apply_fertilizer(fert_name):
+                self._apply_fertilizer(fert_name)
+                print(f"Добавлено удобрение: {fert_name}")
+
+                # Рекурсивно пробуем следующее удобрение
+                if self._backtrack_search(i + 1):
                     return True
 
+                # Откатываемся назад (удаляем последнее удобрение)
+                self._remove_fertilizer(fert_name)
+                print(f"Откат: удалено удобрение {fert_name}")
+
         return False
 
-    def _apply_fertilizer(self, fert_name, amount):
-        """Добавляет указанное количество удобрения"""
+    def _can_apply_fertilizer(self, fert_name):
+        """Проверка, можно ли применить удобрение без перебора"""
+        for element, content in self.fertilizers[fert_name].items():
+            added_ppm = (1 * content * 1000) / self.volume  # Добавляем 1 грамм для проверки
+            if self.actual_profile[element] + added_ppm > self.target_profile[element] + 0.1:
+                return False
+        return True
+
+    def _apply_fertilizer(self, fert_name):
+        """Применение удобрения"""
         if fert_name not in self.results:
-            self._init_fertilizer_record(fert_name)
-            
-        self.results[fert_name]['граммы'] += amount
-        self.results[fert_name]['миллиграммы'] += int(amount * 1000)
-        
-        added_ec = 0.0
+            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)
+
         for element, content in self.fertilizers[fert_name].items():
-            added_ppm = (amount * content * 1000) / self.volume
+            added_ppm = (grams * 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, amount):
-        """Удаляет указанное количество удобрения"""
+    def _remove_fertilizer(self, fert_name):
+        """Удаление удобрения"""
         if fert_name in self.results:
-            self.results[fert_name]['граммы'] -= amount
-            self.results[fert_name]['миллиграммы'] -= int(amount * 1000)
-            
-            removed_ec = 0.0
+            grams = self.results[fert_name]['граммы']
             for element, content in self.fertilizers[fert_name].items():
-                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
+                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
 
     def calculate_ec(self):
         return round(self.total_ec, 2)