Update app.py

app.py

@@ -692,315 +692,237 @@ def nutri_call():
 
 
 
-# Список всех питательных веществ
-nutrients_stencil = [
-    'N (NO3-)', 'N (NH4+)', 'P', 'K', 'Mg', 'Ca', 'S',
-    'Fe', 'Zn', 'B', 'Mn', 'Cu', 'Mo'
-]
-
-# Класс для работы с составами удобрений
-class Composition:
-    def __init__(self, name='', vector=None):
-        self.name = name
-        if vector is None:
-            self.vector = np.zeros(len(nutrients_stencil))
-        else:
-            if len(vector) != len(nutrients_stencil):
-                raise ValueError(f"Vector length ({len(vector)}) does not match "
-                                 f"nutrients stencil length ({len(nutrients_stencil)}).")
-            self.vector = np.array(vector)
-
-    @classmethod
-    def from_dict(cls, composition_dict):
-        if not composition_dict:
-            raise ValueError("Empty composition dictionary provided.")
-        name, nutrients_dict = tuple(composition_dict.items())[0]
-        vector = np.zeros(len(nutrients_stencil))
-        for i, nutrient in enumerate(nutrients_stencil):
-            if nutrient in nutrients_dict:
-                vector[i] = nutrients_dict[nutrient]
-        return cls(name, vector)
-
-    def __add__(self, composition):
-        if not isinstance(composition, Composition):
-            raise TypeError("Can only add Composition objects.")
-        name = f'{self.name} + {composition.name}'
-        vector = self.vector + composition.vector
-        return Composition(name, vector)
-
-    def __neg__(self):
-        return Composition(f'- ({self.name})', -self.vector)
-
-    def __sub__(self, composition):
-        if not isinstance(composition, Composition):
-            raise TypeError("Can only subtract Composition objects.")
-        name = f'{self.name} - {composition.name}'
-        vector = self.vector - composition.vector
-        return Composition(name, vector)
-
-    def __eq__(self, other):
-        if not isinstance(other, Composition):
-            return False
-        return np.all(self.vector == other.vector)
-
-    def __repr__(self):
-        return self.table()
-
-    def __str__(self):
-        return f'{self.name} :: ' + ', '.join(
-                    f'{nutrient}: {amount_ppm:.2f}'
-                    for nutrient, amount_ppm
-                    in zip(nutrients_stencil, 10**6 * self.vector)
-                    )
-
-    def __rmul__(self, number):
-        if not isinstance(number, (int, float)):
-            raise TypeError("Can only multiply by a scalar.")
-        name = f'{number} * ({self.name})'
-        vector = self.vector * number
-        return Composition(name, vector)
-
-    def __len__(self):
-        return len(self.vector)
-
-    def as_dict(self):
-        nutrients_dict = {
-                nutrient: float(value)
-                for nutrient, value in zip(nutrients_stencil, self.vector)
-                if value != 0
-                }
-        return {self.name: nutrients_dict}
-
-    def table(self, sparse=True, ref=None, tablefmt='simple'):
-        description = f'Composition: {self.name}'
-        nutrients = np.array(nutrients_stencil)
-        vector = self.vector
-        if ref is not None:
-            if not isinstance(ref, Composition):
-                raise TypeError("Reference must be a Composition object.")
-            vector_ref = ref.vector
-        else:
-            vector_ref = np.zeros(len(nutrients_stencil))
-        if sparse:
-            mask_nonzero = (vector != 0) | (vector_ref != 0)
-            nutrients = nutrients[mask_nonzero]
-            vector = vector[mask_nonzero]
-            vector_ref = vector_ref[mask_nonzero]
-        table_dict = {
-                'Nutrient': nutrients,
-                'Ratio': vector,
-                'Amount mg/kg': 10**6 * vector,
-                }
-        if ref is not None:
-            description += f'\nReference: {ref.name}'
-            table_dict['Diff mg/kg'] = 10**6 * (vector - vector_ref)
-        table = tabulate(table_dict, headers='keys', tablefmt=tablefmt)
-        return '\n\n'.join((description, table))
 
 
-# Основной класс калькулятора удобрений
-class NutrientCalculator:
-    def __init__(self, volume_liters=1.0):
-        self.volume = volume_liters
+from tabulate import tabulate
 
-        # Целевой профиль (дополнен нулями для отсутствующих элементов)
-        self.target_profile = {nutrient: BASE_PROFILE.get(nutrient, 0.0) for nutrient in nutrients_stencil}
+# Глобальные параметры
+TOTAL_NITROGEN = 120.0 # Общее количество азота
+NO3_RATIO = 8.0         # Соотношение NO3:NH4
+NH4_RATIO = 1.00          # Соотношение NH4:NO3
+VOLUME_LITERS = 100       # Объем раствора
 
-        # Удобрения (дополнены нулями для отсутствующих элементов)
-        self.fertilizers = {
-            name: Composition.from_dict({name: {nutrient: content.get(nutrient, 0.0) for nutrient in nutrients_stencil}})
-            for name, content in NUTRIENT_CONTENT_IN_FERTILIZERS.items()
-        }
+BASE_PROFILE = {
+    "P": 50,      # Фосфор
+    "K": 300,     # Калий
+    "Mg": 120,    # Магний (высокий уровень)
+    "Ca": 150,    # Кальций
+    "S": 100,     # Сера
+    "N (NO3-)": 0,  # Рассчитывается автоматически
+    "N (NH4+)": 0   # Рассчитывается автоматически
+}
 
+NUTRIENT_CONTENT_IN_FERTILIZERS = {
+    "Кальциевая селитра": {"N (NO3-)": 0.11863, "Ca": 0.16972},
+    "Калий азотнокислый": {"N (NO3-)": 0.136, "K": 0.382},
+    "Калий сернокислый": {"K": 0.44874, "S": 0.18401},
+    "Аммоний азотнокислый": {"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}
+}
+
+EC_COEFFICIENTS = {
+    'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015, 
+    'Ca': 0.0016, 'S': 0.0014, 
+    'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
+}
+
+class NutrientCalculator:
+    def __init__(self, volume_liters=1.0, profile=BASE_PROFILE):
+        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.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)
 
-        # Целевой профиль как объект Composition
-        self.target_composition = Composition('Target Profile', list(self.target_profile.values()))
+        # Сохраняем исходный профиль азота
+        self.initial_n_profile = {
+            "NO3-": self.target_profile['N (NO3-)'],
+            "NH4+": self.target_profile['N (NH4+)']
+        }
 
-    def _copy_results(self):
-        """Создаёт глубокую копию результатов"""
-        return {
-            fert_name: {
-                'граммы': data['граммы'],
-                'миллиграммы': data['миллиграммы'],
-                'вклад в EC': data['вклад в EC']
-            }
-            for fert_name, data in self.results.items()
+        # Веса компенсации
+        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)
 
     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
-            else:
-                print("Идеальное решение не найдено. Возвращаю лучшее найденное решение.")
-                return self.best_solution or {"error": "Не удалось найти подходящую комбинацию"}
+            # Первый проход: компенсация основных элементов
+            self._compensate_main_elements()
+
+            # Второй проход: компенсация азота
+            self._compensate_nitrogen()
 
+            # Третий проход: компенсация второстепенных элементов
+            self._compensate_secondary_elements()
+
+            # Четвертый проход: корректировка перебора
+            self._adjust_overages()
+
+            return self.results
         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
-
-        # Текущий профиль как объект 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
+    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
 
-        # Пробуем добавлять удобрения с текущего индекса
-        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
-            
-            # Пробуем добавить удобрение с текущим шагом
-            self._apply_fertilizer(fert_name, step)
+        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 self._backtrack_search(i, step):
-                return True
+            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._remove_fertilizer(fert_name, step)
+            self.results[fert_name]['граммы'] += grams
+            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
             
-            # Пробуем уменьшить шаг для более точного поиска
-            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
-            }
-
-        self.results[fert_name]['граммы'] += amount
-        self.results[fert_name]['миллиграммы'] += int(amount * 1000)
-
-        for i, nutrient in enumerate(nutrients_stencil):
-            added_ppm = scaled_composition.vector[i] * 1000 / self.volume
-            self.actual_profile[nutrient] += added_ppm
-
-    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
+            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
 
-            if self.results[fert_name]['граммы'] <= 0.001:
-                del self.results[fert_name]
+    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_difference(self, current_composition):
-        """Вычисляет общее отклонение от целевого профиля"""
-        diff_vector = self.target_composition.vector - current_composition.vector
-        return np.sum(np.abs(diff_vector))
+    def calculate_ec(self):
+        return round(self.total_ec, 2)
 
-    def generate_report(self):
-        """Генерация отчета о питательном растворе"""
+    def print_initial_nitrogen_report(self):
         try:
-            actual_composition = Composition('Actual Profile', list(self.actual_profile.values()))
-            report = actual_composition.table(sparse=True, ref=self.target_composition)
-            return report
+            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):
+        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("  Все элементы покрыты полностью")
         except Exception as e:
             print(f"Ошибка при выводе отчёта: {str(e)}")
             raise
 
-
-# Пример данных
-BASE_PROFILE = {
-    'N (NO3-)': 106.7,
-    'N (NH4+)': 13.3,
-    'P': 50,
-    'K': 210,
-    'Mg': 120,
-    'Ca': 150,
-    'S': 50
-}
-
-NUTRIENT_CONTENT_IN_FERTILIZERS = {
-    'Кальциевая селитра': {
-        'N (NO3-)': 13.0,
-        'Ca': 17.0
-    },
-    'Калий сернокислый': {
-        'K': 44.0,
-        'S': 18.0
-    },
-    'Магний сернокислый': {
-        'Mg': 9.8,
-        'S': 13.0
-    }
-}
-
-TOTAL_NITROGEN = 120.0
-NO3_RATIO = 90.0
-NH4_RATIO = 10.0
-
-# Создание калькулятора
-calculator = NutrientCalculator(volume_liters=100)
-
-# Расчет
-solution = calculator.calculate()
-
-# Генерация отчета
-if solution:
-    print(calculator.generate_report())
-else:
-    print("Решение не найдено.")
+if __name__ == "__main__":
+    try:
+        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
+        calculator.calculate()
+        calculator.print_report()  # Правильный вызов метода класса
+    except Exception as e:
+        print(f"Критическая ошибка: {str(e)}")