Update app.py

app.py

@@ -712,10 +712,11 @@ def nutri_call():
 
 from tabulate import tabulate
 import numpy as np
+import numpy as np
 
 # Глобальные параметры
 TOTAL_NITROGEN = 120.0  # Общее количество азота
-NO3_RATIO = 8.25         # Соотношение NO3:NH4
+NO3_RATIO = 8.25        # Соотношение NO3:NH4
 NH4_RATIO = 1.0         # Соотношение NH4:NO3
 VOLUME_LITERS = 100     # Объем раствора
 
@@ -743,244 +744,71 @@ EC_COEFFICIENTS = {
     'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
 }
 
-nutrients_stencil = [
-    "N (NO3-)", "N (NH4+)", "P", "K", "Mg", "Ca", "S"
-]
-
-
-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 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, other):
-        if not isinstance(other, Composition):
-            raise TypeError("Can only add Composition objects.")
-        name = f'{self.name} + {other.name}'
-        vector = self.vector + other.vector
-        return Composition(name, vector)
-
-    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))
+nutrients_stencil = list(BASE_PROFILE.keys())
 
 
 class NutrientCalculator:
-    def __init__(self, volume_liters=1.0):
-        self.volume = volume_liters
+    def __init__(self):
+        self.volume = VOLUME_LITERS
         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 = 5000  # Увеличиваем глубину поиска
-        self.current_depth = 0
+        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
+        self.nutrients_stencil = nutrients_stencil
 
         # Расчёт азота
         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.target_vector = np.array([self.target_profile[nutrient] for nutrient in self.nutrients_stencil])
 
     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("Оптимальная комбинация найдена!")
-            else:
-                print("Идеальное решение не найдено. Возвращаю лучшее найденное решение.")
-            
-            # Попытка точного добора после основного подбора
-            self._post_optimize()
-
-            return self.best_solution or {"error": "Не удалось найти подходящую комбинацию"}
+            # П��строение матрицы A (содержание элементов в удобрениях)
+            fertilizer_names = list(self.fertilizers.keys())
+            A = np.zeros((len(self.nutrients_stencil), len(fertilizer_names)))
+            for i, nutrient in enumerate(self.nutrients_stencil):
+                for j, fert_name in enumerate(fertilizer_names):
+                    if nutrient in self.fertilizers[fert_name]:
+                        A[i, j] = self.fertilizers[fert_name][nutrient]
+
+            # Формирование вектора B (целевые значения в ppm)
+            B = self.target_vector * self.volume / 1000  # Перевод ppm в граммы
+
+            # Решение системы уравнений A @ X = B
+            X, residuals, rank, s = np.linalg.lstsq(A, B, rcond=None)
+
+            # Формирование результата
+            results = {}
+            for i, fert_name in enumerate(fertilizer_names):
+                if X[i] > 0:
+                    results[fert_name] = X[i]
+
+            return 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
-
-        # Пробуем добавлять удобрения с текущего индекса
-        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)
-            
-            # Рекурсивно продолжаем поиск
-            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):
-                    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.03:  # Разрешаем перерасход на 3%
-                return False
-        return True
-
-    def _apply_fertilizer(self, fert_name, amount):
-        """Добавляет указанное количество удобрения"""
-        fert_composition = self.fertilizers[fert_name]
-        scaled_composition = Composition(fert_composition.name, fert_composition.vector * amount)
-
-        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 = Composition(fert_composition.name, fert_composition.vector * amount)
-
-        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
-        weights = np.array([1.5 if el in ['K', 'S', 'Mg'] else 1.0 for el in nutrients_stencil])
-        return np.sum(np.abs(diff_vector) * weights)
-
-    def _copy_results(self):
-        """Создаёт глубокую копию результатов"""
-        return {
-            fert_name: {
-                'граммы': data['граммы'],
-                'миллиграммы': data['миллиграммы'],
-                'вклад в EC': data['вклад в EC']
-            }
-            for fert_name, data in self.results.items()
-        }
-
-    def _post_optimize(self):
-        """Попытка точного добора после основного подбора"""
-        for fert_name, fert in self.fertilizers.items():
-            for i, nutrient in enumerate(nutrients_stencil):
-                deficit = self.target_profile[nutrient] - self.actual_profile[nutrient]
-                if deficit > 2.0 and fert.vector[i] > 0:  # Если дефицит больше 2 ppm
-                    small_amount = deficit * self.volume / (fert.vector[i] * 1000)
-                    self._apply_fertilizer(fert_name, min(small_amount, 2.0))  # Не больше 2 г
-
-    def generate_report(self):
+    def generate_report(self, results):
         """Генерация отчета с фактическими данными"""
         try:
-            # Добавляем информацию о добавленных удобрениях
             fertilizer_report = "Фактически добавленные удобрения (в граммах):\n"
-            for fert_name, data in self.results.items():
-                grams = data['граммы']
-                if grams > 0:  # Выводим только те удобрения, которые были добавлены
-                    fertilizer_report += f"  - {fert_name}: {grams:.2f} г\n"
+            for fert_name, grams in results.items():
+                fertilizer_report += f"  - {fert_name}: {grams:.2f} г\n"
 
             return fertilizer_report
         except Exception as e:
             print(f"Ошибка при выводе отчёта: {str(e)}")
             raise
+
+
 if __name__ == "__main__":
     try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        solution = calculator.calculate()
-        if solution:
-            print(calculator.generate_report())
+        calculator = NutrientCalculator()
+        results = calculator.calculate()
+        if results:
+            print(calculator.generate_report(results))
         else:
             print("Решение не найдено.")
     except Exception as e: