Update app.py

app.py

@@ -726,6 +726,8 @@ EC_COEFFICIENTS = {
     'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
 }
 
+import itertools
+
 class NutrientCalculator:
     def __init__(self, volume_liters=1.0, profile=None):
         self.volume = volume_liters
@@ -746,16 +748,8 @@ class NutrientCalculator:
             "NH4+": self.target_profile['N (NH4+)']
         }
 
-        # Веса компенсации
-        self.compensation_weights = {
-            "Ca": {"weight": 0.3, "fert": "Сульфат кальция", "main_element": "Ca"},
-            "K": {"weight": 0.2, "fert": "Калий азотнокислый", "main_element": "K"},
-            "Mg": {"weight": 0.2, "fert": "Сульфат магния", "main_element": "Mg"},
-            "P": {"weight": 0.1, "fert": "Монофосфат калия", "main_element": "P"},
-            "S": {"weight": 0.1, "fert": "Сульфат кальция", "main_element": "S"},
-            "N (NO3-)": {"weight": 0.05, "fert": "Калий азотнокислый", "main_element": "N (NO3-)"},
-            "N (NH4+)": {"weight": 0.05, "fert": "Аммоний азотнокислый", "main_element": "N (NH4+)"}
-        }
+        # Список удобрений для перебора
+        self.fertilizer_list = list(self.fertilizers.keys())
 
     def _label(self, element):
         """Форматирование названий элементов для вывода"""
@@ -767,116 +761,80 @@ class NutrientCalculator:
 
     def calculate(self):
         try:
-            max_iterations = 10  # Максимальное количество итераций для корректировки
-            iteration = 0
-            while iteration < max_iterations:
-                self._reset_actual_profile()
-                self._compensate_main_elements()
-                self._compensate_nitrogen()
-                self._compensate_secondary_elements()
+            max_attempts = 100  # Максимальное количество попыток
+            attempt = 0
+            while attempt < max_attempts:
+                attempt += 1
+                print(f"Попытка {attempt} из {max_attempts}")
 
-                # Проверка результатов
-                if self.validate_results():
-                    break
+                # Генерация случайного порядка удобрений
+                fertilizer_order = self._shuffle_fertilizers()
 
-                # Корректировка перебора
-                self._adjust_overages()
-                iteration += 1
+                # Сброс фактического профиля
+                self._reset_actual_profile()
 
-            if iteration == max_iterations:
-                raise ValueError("Не удалось достичь целевых значений после максимального количества итераций.")
+                # Пробуем рассчитать с текущим порядком удобрений
+                if self._try_combination(fertilizer_order):
+                    print("Успешная комбинация найдена!")
+                    return self.results
+
+            raise ValueError("Не удалось найти подходящую комбинацию удобрений после максимального количества попыток.")
 
-            return self.results
         except Exception as e:
             print(f"Ошибка при расчёте: {str(e)}")
             raise
 
-    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 _shuffle_fertilizers(self):
+        """Генерация случайного порядка удобрений"""
+        return list(itertools.permutations(self.fertilizer_list))[hash(str(self.target_profile)) % len(self.fertilizer_list)]
 
     def _reset_actual_profile(self):
-        """Сброс фактического профиля перед новой итерацией"""
+        """Сброс фактического профиля перед новой попыткой"""
         self.actual_profile = {k: 0.0 for k in self.target_profile}
         self.total_ec = 0.0
         self.results = {}
 
-    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 _try_combination(self, fertilizer_order):
+        """Попытка расчета с заданным порядком удобрений"""
+        for fert_name in fertilizer_order:
+            for element, content in self.fertilizers[fert_name].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 = (required_ppm * self.volume) / (content * 1000)
 
-    def _apply_with_limit(self, fert_name, main_element, required_ppm):
-        """Применение удобрения с ограничением по перебору"""
-        if required_ppm <= 0:
-            return
+                    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
 
-        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
+                    self.results[fert_name]['граммы'] += grams
+                    self.results[fert_name]['миллиграммы'] += int(grams * 1000)
+
+                    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):
-        """Корректировка перебора элементов"""
-        for element in self.actual_profile:
-            if self.actual_profile[element] > self.target_profile[element]:
-                overage = self.actual_profile[element] - self.target_profile[element]
-                self.actual_profile[element] -= overage
-                print(f"Корректировка перебора: {element} уменьшен на {overage:.2f} ppm")
+        # Проверка результатов
+        return self.validate_results()
+
+    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)