Update app.py

app.py

@@ -693,178 +693,271 @@ def nutri_call():
 
 
 
-from tabulate import tabulate
 import numpy as np
+from tabulate import tabulate
 
 # Глобальные параметры
-TOTAL_NITROGEN = 120.0
-NO3_RATIO = 8.0
-NH4_RATIO = 1.0
-VOLUME_LITERS = 100
+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
+    "P": 50,      # Фосфор
+    "K": 210,     # Калий
+    "Mg": 120,    # Магний (высокий уровень)
+    "Ca": 150,    # Кальций
+    "S": 50,      # Сера
+    "N (NO3-)": 0,  # Рассчитывается автоматически
+    "N (NH4+)": 0   # Рассчитывается автоматически
 }
 
-# Состав удобрений (в долях)
-NUTRIENT_CONTENT = {
+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}
+    "Сульфат кальция": {"Ca": 0.23, "S": 0.186},
+    "Кольцевая селитра": {"N (NO3-)": 0.15, "Ca": 0.20}  # Новое удобрение
 }
 
-# Коэффициенты EC
-EC_COEFF = {
-    'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015, 
-    'Ca': 0.0016, 'S': 0.0014, 
+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 __repr__(self):
+        return self.table()
+
+    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=1.0):
-        self.volume = volume
-        self.target = BASE_PROFILE.copy()
-        self._init_nitrogen()
-        self.results = {}
-        self.actual = {k: 0.0 for k in self.target}
+    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.total_ec = 0.0
-        
-    def _init_nitrogen(self):
-        total = NO3_RATIO + NH4_RATIO
-        self.target['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / total)
-        self.target['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / total)
-    
+        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()))
+
     def calculate(self):
-        # 1. Вносим кальций (приоритет Ca(NO3)2)
-        ca_needed = self.target['Ca'] - self.actual['Ca']
-        if ca_needed > 0:
-            self._apply_fert("Кальциевая селитра", "Ca", ca_needed)
-        
-        # 2. Вносим NH4
-        nh4_needed = self.target['N (NH4+)'] - self.actual['N (NH4+)']
-        if nh4_needed > 0:
-            self._apply_fert("Аммоний азотнокислый", "N (NH4+)", nh4_needed)
-        
-        # 3. Компенсируем NO3
-        no3_needed = self.target['N (NO3-)'] - self.actual['N (NO3-)']
-        if no3_needed > 0:
-            self._apply_fert("Калий азотнокислый", "N (NO3-)", no3_needed)
-        
-        # 4. Вносим фосфор
-        p_needed = self.target['P'] - self.actual['P']
-        if p_needed > 0:
-            self._apply_fert("Монофосфат калия", "P", p_needed)
-        
-        # 5. Компенсируем магний
-        mg_needed = self.target['Mg'] - self.actual['Mg']
-        if mg_needed > 0:
-            self._apply_fert("Сульфат магния", "Mg", mg_needed)
-        
-        # 6. Корректируем калий и серу
-        self._balance_k_s()
-        
-        return self._prepare_results()
-    
-    def _apply_fert(self, name, element, needed_ppm):
-        content = NUTRIENT_CONTENT[name][element]
-        grams = (needed_ppm * self.volume) / (content * 1000)
-        
-        if name not in self.results:
-            self.results[name] = {'граммы': 0, 'вклад': {}}
-        
-        self.results[name]['граммы'] += grams
-        
-        for el, val in NUTRIENT_CONTENT[name].items():
-            added = grams * val * 1000 / self.volume
-            self.actual[el] += added
-            self.total_ec += added * EC_COEFF.get(el, 0)
+        try:
+            self.actual_profile = {k: 0.0 for k in self.target_profile}
+            self.results = {}
+            self.current_depth = 0
             
-            if el not in self.results[name]['вклад']:
-                self.results[name]['вклад'][el] = 0
-            self.results[name]['вклад'][el] += added
-    
-    def _balance_k_s(self):
-        k_deficit = self.target['K'] - self.actual['K']
-        s_deficit = self.target['S'] - self.actual['S']
-        
-        # Выбираем удобрение в зависимости от дефицита
-        if k_deficit > 0 and s_deficit > 0:
-            # Используем K2SO4 для одновременного восполнения
-            self._apply_fert("Калий сернокислый", "K", min(k_deficit, s_deficit*0.44874/0.18401))
-        elif k_deficit > 0:
-            self._apply_fert("Калий азотнокислый", "K", k_deficit)
-    
-    def _prepare_results(self):
-        # Расчет дефицитов
-        deficits = {k: self.target[k] - self.actual[k] 
-                   for k in self.target if abs(self.target[k] - self.actual[k]) > 0.1}
-        
-        return {
-            "actual_profile": self.actual,
-            "fertilizers": self._format_fertilizers(),
-            "total_ec": round(self.total_ec, 2),
-            "total_ppm": round(sum(self.actual.values()), 2),
-            "deficits": deficits
-        }
-    
-    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_COEFF.get(k, 0) 
-                                   for k, v in data['вклад'].items()), 3),
-                'добавит': [f"{k}: {round(v, 1)} ppm" for k, v in data['вклад'].items()]
+            if self._backtrack_search():
+                print("Оптимальная комбинация найдена!")
+                return self.best_solution
+            else:
+                print("Идеальное решение не найдено. Возвращаю лучшее найденное решение.")
+                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)
+
+        print(f"\nТекущая разница: {current_diff:.2f}")
+        print("Текущий профиль:")
+        print(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
             }
-        return formatted
-    
-    def print_report(self):
-        print("\n" + "="*60)
-        print("ПРОФИЛЬ ПИТАТЕЛЬНОГО РАСТВОРА (ИТОГО):")
-        print("="*60)
-        print(tabulate([[k, round(v, 1)] for k, v in self.actual.items()], 
-                     headers=["Элемент", "ppm"]))
-        
-        print("\n" + "="*60)
-        print(f"РАСЧЕТ ДЛЯ {self.volume} ЛИТРОВ")
-        print("="*60)
-        print(f"Общая концентрация: {round(sum(self.actual.values()), 1)} ppm")
-        print(f"EC: {round(self.total_ec, 2)} mS/cm")
-        
-        print("\nРЕКОМЕНДУЕМЫЕ УДОБРЕНИЯ:")
-        fert_table = []
-        for name, data in self._format_fertilizers().items():
-            fert_table.append([
-                name,
-                data['граммы'],
-                data['миллиграммы'],
-                data['вклад в EC'],
-                "\n".join(data['добавит'])
-            ])
-        print(tabulate(fert_table, 
-                      headers=["Удобрение", "Граммы", "Миллиграммы", "EC", "Добавит"]))
-        
-        if self._prepare_results()['deficits']:
-            print("\nОСТАТОЧНЫЙ ДЕФИЦИТ:")
-            for el, val in self._prepare_results()['deficits'].items():
-                print(f"  {el}: {round(val, 1)} ppm")
-        else:
-            print("\nВсе элементы покрыты полностью")
+            
+            if current_diff < 1.0:  # Допустимая погрешность
+                return True
 
-# Пример использования
-if __name__ == "__main__":
-    calc = NutrientCalculator(VOLUME_LITERS)
-    results = calc.calculate()
-    calc.print_report()
+        # Пробуем добавлять удобрения с текущего индекса
+        for i in range(fertilizer_index, len(self.fertilizers)):
+            fert_name = list(self.fertilizers.keys())[i]
+            fert_composition = self.fertilizers[fert_name]
+
+            print(f"\nПроверяю удобрение: {fert_name}")
+
+            # Проверяем, можно ли применить удобрение
+            if not self._can_apply_fertilizer(fert_composition):
+                print(f"Удобрение {fert_name} не подходит (превышает целевые значения).")
+                continue
+            
+            print(f"Добавляю удобрение: {fert_name}, количество: {step:.2f} г")
 
+            # Пробуем добавить удобрение с текущим шагом
+            self._apply_fertilizer(fert_name, step)
+            
+            # Рекурсивно продолжаем поиск
+            if self._backtrack_search(i, step):
+                return True
+                
+            # Если не получилось - откатываемся
+            print(f"Откатываю удобрение: {fert_name}, количество: {step:.2f} г")
+            self._remove_fertilizer(fert_name, step)
+            
+            # Пробуем уменьшить шаг для более точного поиска
+            if step > 0.1 and current_diff > 5.0:
+                print(f"Уменьшаю шаг до {step / 2:.2f} г")
+                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] + 0.5:  # Уменьшаем допустимую погрешность
+                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
+
+            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:
+            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)}")