Update app.py

app.py

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