Update app.py

app.py

@@ -790,74 +790,75 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
 }
 
 class NutrientCalculator:
-    def __init__(self, volume_liters: float = 1.0):
+    def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         self.results = {}
-        self.target_profile = {
-            'P': 31.0, 'K': 210.0, 'Mg': 24.0,
-            'Ca': 84.0, 'S': 56.439,
-            'N (NO3-)': 0.0, 'N (NH4+)': 0.0
-        }
-        self.actual_profile = {k: 0.0 for k in self.target_profile}
+        self.target_profile = BASE_PROFILE.copy()
+        self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
+        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
         self.total_ec = 0.0
-        self.fertilizers = {}
 
-        # Коэффициенты для расчета EC (мСм/см на ppm)
-        self.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
+        # Веса для компенсации
+        self.compensation_weights = {
+            "POTASSIUM_NITRATE": {"weight": 0.5, "fert": "Калий азотнокислый", "main_element": "K"},
+            "CALCIUM_NITRATE": {"weight": 0.3, "fert": "Кальциевая селитра", "main_element": "Ca"},
+            "POTASSIUM_SULFATE": {"weight": 0.2, "fert": "Калий сернокислый", "main_element": "K"}
         }
 
-        # Новая структура весов для компенсации
-        self.compensation_weights = {
-            'POTASSIUM_NITRATE': {'weight': 0.5, 'fert': 'Калий азотнокислый', 'main_element': 'K'},
-            'CALCIUM_NITRATE': {'weight': 0.3, 'fert': 'Кальциевая селитра', 'main_element': 'Ca'},
-            'POTASSIUM_SULFATE': {'weight': 0.2, 'fert': 'Калий сернокислый', 'main_element': 'K'}
+        # Расчёт азота (оставляем без изменений)
+        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+)']
         }
 
-    def _apply_fertilizer(self, fert_name: str, element: str, ppm: float):
-        """Основной метод внесения удобрений с расчетом EC"""
-        try:
-            if ppm <= 0:
-                return
+    def _label(self, element):
+        """Форматирование названий элементов для вывода"""
+        labels = {
+            'N (NO3-)': 'NO3',
+            'N (NH4+)': 'NH4'
+        }
+        return labels.get(element, element)
 
-            content = self.fertilizers[fert_name][element]
-            grams = (ppm * self.volume) / (content * 1000)
-            milligrams = grams * 1000
+    def _apply(self, fert_name, main_element, required_ppm):
+        """Внесение удобрения"""
+        if required_ppm <= 0:
+            return
+            
+        try:
+            content = self.fertilizers[fert_name][main_element]
+            grams = (required_ppm * self.volume) / (content * 1000)
             
             if fert_name not in self.results:
-                self.results[fert_name] = {
+                result = {
                     'граммы': 0.0,
                     'миллиграммы': 0,
-                    'вклад в EC': 0.0,
-                    'внесенные ppm': {}
+                    'вклад в EC': 0.0
                 }
-
+                for element in self.fertilizers[fert_name]:
+                    result[f'внесет {self._label(element)}'] = 0.0
+                self.results[fert_name] = result
+                
             self.results[fert_name]['граммы'] += grams
             self.results[fert_name]['миллиграммы'] = int(self.results[fert_name]['граммы'] * 1000)
             
-            # Расчет EC и внесенных ppm
             fert_ec = 0.0
-            for el, percent in self.fertilizers[fert_name].items():
+            for element, percent in self.fertilizers[fert_name].items():
                 added_ppm = (grams * percent * 1000) / self.volume
-                self.actual_profile[el] += added_ppm
-                self.results[fert_name]['внесенные ppm'][el] = self.results[fert_name]['внесенные ppm'].get(el, 0) + added_ppm
-                fert_ec += added_ppm * self.ec_coefficients.get(el, 0.0015)
-            
+                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:
-            raise ValueError(f"Ошибка в данных удобрений: {str(e)}")
-
-    def calculate_ec(self) -> float:
-        """Возвращает общую электропроводность (EC)"""
-        return round(self.total_ec, 2)
+            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
+            raise
 
     def _compensate_element(self, element: str, needed_ppm: float):
-        """Исправленная компенсация с учетом новых весов и приоритетов азота"""
-        # Находим подходящие удобрения для элемента
+        """Компенсация дефицита элемента с учетом весов"""
         suitable_ferts = []
         for fert_key, fert_data in self.compensation_weights.items():
             fert_name = fert_data['fert']
@@ -869,78 +870,120 @@ class NutrientCalculator:
                 })
         
         if not suitable_ferts:
-            raise ValueError(f"Нет удобрений для элемента {element}")
+            raise ValueError(f"Нет подходящих удобрений для элемента {element}")
 
-        # Рассчитываем общий вес для нормализации
         total_weight = sum(f['weight'] for f in suitable_ferts)
-        
-        # Распределяем дефицит пропорционально весам
-        remaining_ppm = needed_ppm
         for fert in suitable_ferts:
-            if remaining_ppm <= 0:
-                break
-                
-            # Вычисляем долю удобрения
             share = fert['weight'] / total_weight
-            ppm_to_apply = remaining_ppm * share
-            
-            # Вносим удобрение
-            self._apply_fertilizer(fert['name'], element, ppm_to_apply)
-            
-            # Обновляем остаток дефицита
-            remaining_ppm = self.target_profile[element] - self.actual_profile[element]
+            ppm_to_apply = needed_ppm * share
+            self._apply(fert['name'], element, ppm_to_apply)
+
+    def _apply_k_sulfate(self):
+        """Внесение калия сернокислого с учетом весов"""
+        s_def = self.target_profile['S'] - self.actual_profile['S']
+        if s_def > 0.1:
+            self._compensate_element("S", s_def)
 
     def calculate(self):
-        """Основной расчет с учетом новых приоритетов"""
+        """Основной расчет"""
         try:
-            # 1. Вносим магний (сульфат магния)
-            self._apply_fertilizer("Сульфат магния", "Mg", self.target_profile['Mg'])
+            # 1. Вносим магний
+            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
+            
+            # 2. Вносим кальций
+            self._apply("Кальциевая селитра", "Ca", self.target_profile['Ca'])
             
-            # 2. Вносим аммонийный азот
-            self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
+            # 3. Вносим фосфор
+            self._apply("Монофосфат калия", "P", self.target_profile['P'])
             
-            # 3. Компенсируем нитратный азот с учетом новых весов
-            if self.target_profile['N (NO3-)'] > 0:
-                self._compensate_element("N (NO3-)", self.target_profile['N (NO3-)'])
+            # 4. Вносим аммонийный азот (логика не меняется)
+            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
             
-            # 4. Вносим фосфор
-            self._apply_fertilizer("Монофосфат калия", "P", self.target_profile['P'])
+            # 5. Компенсируем нитратный азот (логика не меняется)
+            current_no3 = self.actual_profile['N (NO3-)']
+            no3_needed = self.target_profile['N (NO3-)'] - current_no3
+            if no3_needed > 0.1:
+                self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
             
-            # 5. Компенсируем калий с учетом новых весов
-            if self.target_profile['K'] > self.actual_profile['K']:
-                self._compensate_element("K", self.target_profile['K'] - self.actual_profile['K'])
+            # 6. Вносим серу и калий с учетом весов
+            self._apply_k_sulfate()
             
-            # 6. Компенсируем кальций (если нужно)
-            ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
-            if ca_needed > 0:
-                self._compensate_element("Ca", ca_needed)
+            # 7. Компенсируем остаточный дефицит калия с учетом весов
+            k_deficit = self.target_profile['K'] - self.actual_profile['K']
+            if k_deficit > 0.1:
+                self._compensate_element("K", k_deficit)
             
-            return self._prepare_results()
+            return self.results
+        except Exception as e:
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
 
+    def calculate_ec(self):
+        """Расчет общей электропроводности"""
+        return round(self.total_ec, 2)
+
+    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:
-            raise RuntimeError(f"Ошибка расчета: {str(e)}")
-
-    def _prepare_results(self) -> dict:
-        """Подготовка результатов для API"""
-        return {
-            'actual_profile': {k: round(v, 2) for k, v in self.actual_profile.items()},
-            'fertilizers': {
-                fert: {
-                    'граммы': round(data['граммы'], 3),
-                    'миллиграммы': data['миллиграммы'],
-                    'вклад в EC': round(data['вклад в EC'], 3),
-                    'внесенные ppm': {k: round(v, 2) for k, v in data['внесенные ppm'].items()}
-                }
-                for fert, data in self.results.items()
-            },
-            'total_ec': self.calculate_ec(),
-            'total_ppm': round(sum(self.actual_profile.values()), 2),
-            'nitrogen_ratios': {
-                'NO3': round(self.target_profile['N (NO3-)'], 2),
-                'NH4': round(self.target_profile['N (NH4+)'], 2)
-            },
-            'compensation_weights': self.compensation_weights
-        }
+            print(f"Ошибка при выводе отчёта: {str(e)}")
+            raise
+
+if __name__ == "__main__":
+    # Убедитесь, что эти константы определены
+    TOTAL_NITROGEN = 155.0  # Примерное значение, замените на своё
+    NO3_RATIO = 9.0         # Примерное значение, замените на своё
+    NH4_RATIO = 1.0         # Примерное значение, замените на своё
+    VOLUME_LITERS = 1.0     # Примерное значение, замените на своё
+
+    try:
+        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
+        calculator.calculate()
+        calculator.print_report()
+    except Exception as e:
+        print(f"Критическая ошибка: {str(e)}")
+
 
 
 @app.route('/calculation', methods=['POST'])