Update app.py

app.py

@@ -701,7 +701,6 @@ def nutri_call():
 
 
 
-
 from tabulate import tabulate
 
 # Глобальные параметры
@@ -712,10 +711,10 @@ VOLUME_LITERS = 100       # Объем раствора
 
 BASE_PROFILE = {
     "P": 50,      # Фосфор
-    "K": 300,     # Калий
+    "K": 210,     # Калий
     "Mg": 120,    # Магний (высокий уровень)
     "Ca": 150,    # Кальций
-    "S": 100,     # Сера
+    "S": 50,     # Сера
     "N (NO3-)": 0,  # Рассчитывается автоматически
     "N (NH4+)": 0   # Рассчитывается автоматически
 }
@@ -727,7 +726,8 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
     "Аммоний азотнокислый": {"N (NO3-)": 0.17499, "N (NH4+)": 0.17499},
     "Сульфат магния": {"Mg": 0.09861, "S": 0.13010},
     "Монофосфат калия": {"P": 0.218, "K": 0.275},
-    "Сульфат кальция": {"Ca": 0.23, "S": 0.186}
+    "Сульфат кальция": {"Ca": 0.23, "S": 0.186},
+    "Кольцевая селитра": {"N (NO3-)": 0.15, "Ca": 0.20}  # Новое удобрение
 }
 
 EC_COEFFICIENTS = {
@@ -736,194 +736,154 @@ EC_COEFFICIENTS = {
     'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
 }
 
+
+
 class NutrientCalculator:
-    def __init__(self, volume_liters=1.0, profile=BASE_PROFILE):
+    def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
-        self.results = {}
-        self.target_profile = profile.copy()
-        self.actual_profile = {k: 0.0 for k in self.target_profile}
-        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
+        self.target_profile = BASE_PROFILE.copy()
+        self.fertilizers = {
+            name: Composition.from_dict({name: content})
+            for name, content in NUTRIENT_CONTENT_IN_FERTILIZERS.items()
+        }
         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.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):
-        """Форматирование названий элементов для вывода"""
-        labels = {
-            'N (NO3-)': 'NO3',
-            'N (NH4+)': 'NH4'
-        }
-        return labels.get(element, element)
+        # Целевой профиль как объект Composition
+        self.target_composition = Composition('Target Profile', list(self.target_profile.values()))
 
     def calculate(self):
         try:
-            # Первый проход: компенсация основных элементов
-            self._compensate_main_elements()
-
-            # Второй проход: компенсация азота
-            self._compensate_nitrogen()
-
-            # Третий проход: компенсация второстепенных элементов
-            self._compensate_secondary_elements()
-
-            # Четвертый проход: корректировка перебора
-            self._adjust_overages()
+            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
+            else:
+                print("Идеальное решение не найдено. Возвращаю лучшее найденное решение.")
+                return self.best_solution or {"error": "Не удалось найти подходящую комбинацию"}
 
-            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]
-                if required_ppm > 0.1:
-                    self._apply_with_limit(fert_name, main_element, required_ppm)
-
-    def _apply_with_limit(self, fert_name, main_element, required_ppm):
-        """Применение удобрения с ограничением по перебору"""
-        if required_ppm <= 0:
-            return
+    def _backtrack_search(self, fertilizer_index=0, step=1.0):
+        self.current_depth += 1
+        if self.current_depth > self.max_recursion_depth:
+            return False
+
+        # Текущий профиль как объект Composition
+        current_composition = Composition('Current Profile', list(self.actual_profile.values()))
+        current_diff = self._calculate_difference(current_composition)
+
+        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 < 1.0:  # Допустимая погрешность
+                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))
+        # Пробуем добавлять удобрения с текущего индекса
+        for i in range(fertilizer_index, len(self.fertilizers)):
+            fert_name = list(self.fertilizers.keys())[i]
+            fert_composition = self.fertilizers[fert_name]
+
+            # Проверяем, можно ли применить удобрение
+            if not self._can_apply_fertilizer(fert_composition):
+                continue
             
-            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)
+            # Пробуем добавить удобрение с текущим шагом
+            self._apply_fertilizer(fert_name, step)
             
-            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)
+            # Рекурсивно продолжаем поиск
+            if self._backtrack_search(i, step):
+                return True
                 
-            self.results[fert_name]['вклад в EC'] += fert_ec
-            self.total_ec += fert_ec
-        except KeyError as e:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
-            raise
+            # Если не получилось - откатываемся
+            self._remove_fertilizer(fert_name, step)
+            
+            # Пробуем уменьшить шаг для более точного поиска
+            if step > 0.1 and current_diff > 5.0:
+                if self._backtrack_search(i, step / 2):
+                    return True
+
+        return False
+
+    def _can_apply_fertilizer(self, fert_composition):
+        """Проверяет, можно ли применить удобрение без перебора"""
+        for element, content in zip(nutrients_stencil, fert_composition.vector):
+            added_ppm = (1 * content * 1000) / self.volume
+            if self.actual_profile[element] + added_ppm > self.target_profile[element] + 1.0:
+                return False
+        return True
+
+    def _apply_fertilizer(self, fert_name, amount):
+        """Добавляет указанное количество удобрения"""
+        fert_composition = self.fertilizers[fert_name]
+        scaled_composition = amount * fert_composition
+
+        if fert_name not in self.results:
+            self.results[fert_name] = {
+                'граммы': 0.0,
+                'миллиграммы': 0,
+                'вклад в EC': 0.0
+            }
 
-    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")
+        self.results[fert_name]['граммы'] += amount
+        self.results[fert_name]['миллиграммы'] += int(amount * 1000)
 
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
+        for i, nutrient in enumerate(nutrients_stencil):
+            added_ppm = scaled_composition.vector[i] * 1000 / self.volume
+            self.actual_profile[nutrient] += added_ppm
 
-    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 print_report(self):
+    def _remove_fertilizer(self, fert_name, amount):
+        """Удаляет указанное количество удобрения"""
+        fert_composition = self.fertilizers[fert_name]
+        scaled_composition = amount * fert_composition
+
+        if fert_name in self.results:
+            self.results[fert_name]['граммы'] -= amount
+            self.results[fert_name]['миллиграммы'] -= int(amount * 1000)
+
+            for i, nutrient in enumerate(nutrients_stencil):
+                removed_ppm = scaled_composition.vector[i] * 1000 / self.volume
+                self.actual_profile[nutrient] -= removed_ppm
+
+            if self.results[fert_name]['граммы'] <= 0.001:
+                del self.results[fert_name]
+
+    def _calculate_difference(self, current_composition):
+        """Вычисляет общее отклонение от целевого профиля"""
+        diff_vector = self.target_composition.vector - current_composition.vector
+        return np.sum(np.abs(diff_vector))
+
+    def generate_report(self):
+        """Генерация отчета о питательном растворе"""
         try:
-            print("\n" + "="*60)
-            print("ПРОФИЛЬ ПИТАТЕЛЬНОГО РАСТВОРА (ИТОГО):")
-            print("="*60)
-            table = [[el, round(self.actual_profile[el], 1)] for el in self.actual_profile]
-            print(tabulate(table, headers=["Элемент", "ppm"]))
-
-            print("\nИсходный расчёт азота:")
-            for form, val in self.initial_n_profile.items():
-                print(f"  {form}: {round(val, 1)} ppm")
-
-            print("\n" + "="*60)
-            print(f"РАСЧЕТ ДЛЯ {self.volume} ЛИТРОВ РАСТВОРА")
-            print("="*60)
-            print(f"Общая концентрация: {round(sum(self.actual_profile.values()), 1)} ppm")
-            print(f"EC: {self.calculate_ec()} mS/cm")
-
-            print("\nРЕКОМЕНДУЕМЫЕ УДОБРЕНИЯ:")
-            fert_table = []
-            for fert, data in self.results.items():
-                adds = [f"+{k}: {v:.1f} ppm" for k, v in data.items() if k.startswith('внесет')]
-                fert_table.append([
-                    fert,
-                    round(data['граммы'], 3),
-                    data['миллиграммы'],
-                    round(data['вклад в EC'], 3),
-                    "\n".join(adds)
-                ])
-            print(tabulate(fert_table, 
-                         headers=["Удобрение", "Граммы", "Миллиграммы", "EC (мСм/см)", "Добавит"]))
-
-            print("\nОСТАТОЧНЫЙ ДЕФИЦИТ:")
-            deficit = {
-                k: round(self.target_profile[k] - self.actual_profile[k], 1)
-                for k in self.target_profile
-                if abs(self.target_profile[k] - self.actual_profile[k]) > 0.1
-            }
-            if deficit:
-                for el, val in deficit.items():
-                    print(f"  {el}: {val} ppm")
-            else:
-                print("  Все элементы покрыты полностью")
+            actual_composition = Composition('Actual Profile', list(self.actual_profile.values()))
+            report = actual_composition.table(sparse=True, ref=self.target_composition)
+            return report
         except Exception as e:
             print(f"Ошибка при выводе отчёта: {str(e)}")
             raise
 
+   
+
 if __name__ == "__main__":
     try:
         calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)