Update app.py

app.py

@@ -693,283 +693,132 @@ def nutri_call():
 
 
 
-from tabulate import tabulate
-import numpy as np
-
-# Глобальные параметры
-TOTAL_NITROGEN = 120.0  # Общее количество азота
-NO3_RATIO = 8.0         # Соотношение NO3:NH4
-NH4_RATIO = 1.0         # Соотношение NH4:NO3
-VOLUME_LITERS = 100     # Объем раствора
-
-BASE_PROFILE = {
-    "P": 50,      # Фосфор
-    "K": 210,     # Калий
-    "Mg": 120,    # Магний (высокий уровень)
-    "Ca": 150,    # Кальций
-    "S": 50,      # Сера
-    "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},
-    "Кольцевая селитра": {"N (NO3-)": 0.15, "Ca": 0.20}  # Новое удобрение
-}
-
-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
-}
-
-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))
-
-
 class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         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._init_nitrogen()
+        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
+        self.results = {}
+        self.actual_profile = {k: 0.0 for k in self.target_profile}
         self.total_ec = 0.0
-        self.best_solution = None
-        self.min_difference = float('inf')
-        self.max_recursion_depth = 5000  # Увеличиваем глубину поиска
-        self.current_depth = 0
+        self.tolerance = 0.5  # Допустимое отклонение в ppm
 
-        # Расчёт азота
+    def _init_nitrogen(self):
         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()))
-
     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": "Не удалось найти подходящую комбинацию"}
-
-        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]
+        # Основные элементы в порядке приоритета
+        elements_order = ['Ca', 'N (NH4+)', 'P', 'Mg', 'N (NO3-)', 'K', 'S']
+        
+        for element in elements_order:
+            self._balance_element(element)
+        
+        # Финальная тонкая настройка
+        self._fine_tuning()
+        
+        return self._prepare_results()
 
-            # Проверяем, можно ли применить удобрение
-            if not self._can_apply_fertilizer(fert_composition):
-                continue
+    def _balance_element(self, element):
+        deficit = self.target_profile[element] - self.actual_profile[element]
+        if deficit <= self.tolerance:
+            return
             
-            # Пробуем добавить удобрение с текущим шагом
-            self._apply_fertilizer(fert_name, step)
+        # Выбираем лучшее удобрение для элемента
+        best_fert = self._find_best_fertilizer(element)
+        if not best_fert:
+            return
             
-            # Рекурсивно продолжаем поиск
-            if self._backtrack_search(i, step):
-                return True
-                
-            # Если не получилось - откатываемся
-            self._remove_fertilizer(fert_name, step)
+        # Рассчитываем необходимое количество
+        content = self.fertilizers[best_fert][element]
+        grams = (deficit * self.volume) / (content * 1000)
+        
+        # Вносим с учетом других элементов в удобрении
+        self._apply_fertilizer(best_fert, grams)
+
+    def _find_best_fertilizer(self, element):
+        candidates = []
+        for fert, contents in self.fertilizers.items():
+            if element in contents:
+                # Оцениваем "побочные" элементы
+                side_effects = sum(
+                    max(0, self.target_profile[e] - self.actual_profile[e]) 
+                    for e in contents if e != element
+                )
+                candidates.append((fert, side_effects))
+        
+        if not candidates:
+            return None
             
-            # Уменьшаем шаг для более точного поиска
-            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)
+        # Выбираем удобрение с минимальными побочными эффектами    
+        return min(candidates, key=lambda x: x[1])[0]
 
+    def _apply_fertilizer(self, fert_name, grams):
         if fert_name not in self.results:
             self.results[fert_name] = {
                 'граммы': 0.0,
-                'миллиграммы': 0,
-                'вклад в EC': 0.0
+                'вклад': {e: 0.0 for e in self.fertilizers[fert_name]}
             }
+        
+        self.results[fert_name]['граммы'] += grams
+        
+        for element, content in self.fertilizers[fert_name].items():
+            added_ppm = (grams * content * 1000) / self.volume
+            self.actual_profile[element] += added_ppm
+            self.results[fert_name]['вклад'][element] += added_ppm
+            self.total_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
+
+    def _fine_tuning(self):
+        # Тонкая подстройка малыми шагами (0.1 грамма)
+        for _ in range(100):  # Максимум 100 итераций
+            worst_element = self._get_worst_balanced()
+            if not worst_element:
+                break
+                
+            self._balance_element(worst_element)
 
-        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 _get_worst_balanced(self):
+        worst_element = None
+        max_diff = 0
+        
+        for element in self.target_profile:
+            diff = abs(self.target_profile[element] - self.actual_profile[element])
+            if diff > max_diff and diff > self.tolerance:
+                max_diff = diff
+                worst_element = element
+                
+        return worst_element
 
-    def _copy_results(self):
-        """Создаёт глубокую копию результатов"""
+    def _prepare_results(self):
+        deficits = {
+            k: round(self.target_profile[k] - self.actual_profile[k], 3)
+            for k in self.target_profile 
+            if abs(self.target_profile[k] - self.actual_profile[k]) > self.tolerance
+        }
+        
         return {
-            fert_name: {
-                'граммы': data['граммы'],
-                'миллиграммы': data['миллиграммы'],
-                'вклад в EC': data['вклад в EC']
-            }
-            for fert_name, data in self.results.items()
+            "actual_profile": {k: round(v, 3) for k, v in self.actual_profile.items()},
+            "fertilizers": self._format_fertilizers(),
+            "total_ec": round(self.total_ec, 3),
+            "total_ppm": round(sum(self.actual_profile.values()), 3),
+            "deficits": deficits
         }
 
-    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):
-        """Генерация отчета о питательном растворе"""
-        try:
-            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)
-        solution = calculator.calculate()
-        if solution:
-            print(calculator.generate_report())
-        else:
-            print("Решение не найдено.")
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
-
+    def _format_fertilizers(self):
+        formatted = {}
+        for name, data in self.results.items():
+            formatted[name] = {
+                'граммы': round(data['граммы'], 3),
+                'миллиграммы': int(data['граммы'] * 1000),
+                'вклад в EC': round(sum(
+                    v * EC_COEFFICIENTS.get(k, 0.0015) 
+                    for k, v in data['вклад'].items()
+                ), 3),
+                'добавит': [f"{k}: {round(v, 3)} ppm" for k, v in data['вклад'].items()]
+            }
+        return formatted