Update app.py

app.py

@@ -733,24 +733,23 @@ class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         self.target_profile = BASE_PROFILE.copy()
-        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
+        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.max_recursion_depth = 1000
         self.current_depth = 0
-        self.fertilizer_list = list(self.fertilizers.keys())
 
         # Расчёт азота
         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+)']
-        }
+        # Целевой профиль как объект Composition
+        self.target_composition = Composition('Target Profile', list(self.target_profile.values()))
 
     def calculate(self):
         try:
@@ -762,7 +761,8 @@ class NutrientCalculator:
                 print("Оптимальная комбинация найдена!")
                 return self.best_solution
             else:
-                return self.best_solution or {"error": "Не удалось найти идеальную комбинацию"}
+                print("Идеальное решение не найдено. Возвращаю лучшее найденное решение.")
+                return self.best_solution or {"error": "Не удалось найти подходящую комбинацию"}
 
         except Exception as e:
             print(f"Ошибка при расчёте: {str(e)}")
@@ -773,8 +773,10 @@ class NutrientCalculator:
         if self.current_depth > self.max_recursion_depth:
             return False
 
-        # Проверяем текущее решение
-        current_diff = self._calculate_difference()
+        # Текущий профиль как объект 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 = {
@@ -784,15 +786,16 @@ class NutrientCalculator:
                 "difference": current_diff
             }
             
-            if current_diff < 0.1:  # Допустимая погрешность
+            if current_diff < 1.0:  # Допустимая погрешность
                 return True
 
         # Пробуем добавлять удобрения с текущего индекса
-        for i in range(fertilizer_index, len(self.fertilizer_list)):
-            fert_name = self.fertilizer_list[i]
-            
+        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_name):
+            if not self._can_apply_fertilizer(fert_composition):
                 continue
             
             # Пробуем добавить удобрение с текущим шагом
@@ -806,158 +809,71 @@ class NutrientCalculator:
             self._remove_fertilizer(fert_name, step)
             
             # Пробуем уменьшить шаг для более точного поиска
-            if step > 0.1 and current_diff > 1.0:
+            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_name):
+    def _can_apply_fertilizer(self, fert_composition):
         """Проверяет, можно ли применить удобрение без перебора"""
-        for element, content in self.fertilizers[fert_name].items():
+        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.1:
+            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._init_fertilizer_record(fert_name)
-            
+            self.results[fert_name] = {
+                'граммы': 0.0,
+                'миллиграммы': 0,
+                'вклад в EC': 0.0
+            }
+
         self.results[fert_name]['граммы'] += amount
         self.results[fert_name]['миллиграммы'] += int(amount * 1000)
-        
-        added_ec = 0.0
-        for element, content in self.fertilizers[fert_name].items():
-            added_ppm = (amount * content * 1000) / self.volume
-            self.results[fert_name][f'внесет {element}'] += added_ppm
-            self.actual_profile[element] += added_ppm
-            added_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
-            
-        self.results[fert_name]['вклад в EC'] += added_ec
-        self.total_ec += added_ec
+
+        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)
-            
-            removed_ec = 0.0
-            for element, content in self.fertilizers[fert_name].items():
-                removed_ppm = (amount * content * 1000) / self.volume
-                self.results[fert_name][f'внесет {element}'] -= removed_ppm
-                self.actual_profile[element] -= removed_ppm
-                removed_ec += removed_ppm * EC_COEFFICIENTS.get(element, 0.0015)
-                
-            self.results[fert_name]['вклад в EC'] -= removed_ec
-            self.total_ec -= removed_ec
-            
+
+            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):
+    def _calculate_difference(self, current_composition):
         """Вычисляет общее отклонение от целевого профиля"""
-        return sum(
-            abs(self.actual_profile[e] - self.target_profile[e])
-            for e in self.target_profile
-        )
-
-    def _copy_results(self):
-        """Создаёт глубокую копию результатов"""
-        return {
-            fert: data.copy()
-            for fert, data in self.results.items()
-        }
-
-    def _init_fertilizer_record(self, fert_name):
-        """Инициализирует запись для нового удобрения"""
-        self.results[fert_name] = {
-            'граммы': 0.0,
-            'миллиграммы': 0,
-            'вклад в EC': 0.0
-        }
-        for elem in self.fertilizers[fert_name]:
-            self.results[fert_name][f'внесет {elem}'] = 0.0
+        diff_vector = self.target_composition.vector - current_composition.vector
+        return np.sum(np.abs(diff_vector))
 
     def generate_report(self):
         """Генерация отчета о питательном растворе"""
         try:
-            report = "============================================================\n"
-            report += "ПРОФИЛЬ ПИТАТЕЛЬНОГО РАСТВОРА (ИТОГО):\n"
-            report += "============================================================\n"
-            report += f"{'Элемент':<10} {'ppm':>10}\n"
-            report += "-" * 20 + "\n"
-            for element, value in self.actual_profile.items():
-                report += f"{element:<10} {value:>10.2f}\n"
-
-            report += "\nИсходный расчёт азота:\n"
-            report += f"  NO3-: {self.initial_n_profile['NO3-']:.2f} ppm\n"
-            report += f"  NH4+: {self.initial_n_profile['NH4+']:.2f} ppm\n"
-
+            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
 
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
-
-    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):
-        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
+   
 
 if __name__ == "__main__":
     try: