Update app.py

app.py

@@ -693,237 +693,177 @@ def nutri_call():
 
 
 
-
 from tabulate import tabulate
+import numpy as np
 
-# Константы
-TOTAL_NITROGEN = 125.000
-NO3_RATIO = 8.25
-NH4_RATIO = 1.00
+# Глобальные параметры
+TOTAL_NITROGEN = 120.0
+NO3_RATIO = 8.0
+NH4_RATIO = 1.0
 VOLUME_LITERS = 100
 
-# Коэффициенты электропроводности
-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
-}
-
-# Базовый профиль питательного раствора
+# Базовый профиль
 BASE_PROFILE = {
-    'P': 31.000, 'K': 210.000, 'Mg': 24.000,
-    'Ca': 84.000, 'S': 56.439,
-    'N (NO3-)': 0, 'N (NH4+)': 0
+    "P": 50, "K": 210, "Mg": 120,
+    "Ca": 150, "S": 50,
+    "N (NO3-)": 0, "N (NH4+)": 0
 }
 
-# Содержание элементов в удобрениях
-NUTRIENT_CONTENT_IN_FERTILIZERS = {
+# Состав удобрений (в долях)
+NUTRIENT_CONTENT = {
     "Кальциевая селитра": {"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},
-    "Калий сернокислый": {"K": 0.44874, "S": 0.18401}
+    "Сульфат кальция": {"Ca": 0.23, "S": 0.186}
+}
+
+# Коэффициенты EC
+EC_COEFF = {
+    'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015, 
+    'Ca': 0.0016, 'S': 0.0014, 
+    'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
 }
 
 class NutrientCalculator:
-    def __init__(self, volume_liters=1.0):
-        # Общие параметры
-        self.volume = volume_liters
+    def __init__(self, volume=1.0):
+        self.volume = volume
+        self.target = BASE_PROFILE.copy()
+        self._init_nitrogen()
         self.results = {}
-        self.target_profile = BASE_PROFILE.copy()
-        self.actual_profile = {k: 0.0 for k in BASE_PROFILE}
-        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
+        self.actual = {k: 0.0 for k in self.target}
         self.total_ec = 0.0
-
-        # Веса компенсации для элементов
-        self.element_compensation_weights = {
-            "POTASSIUM_SULFATE": {"weight": 0.18, "fert": "Калий сернокислый", "main_element": "K"},
-            "MAGNESIUM_SULFATE": {"weight": -0.08, "fert": "Сульфат магния", "main_element": "Mg"},
-            "MONOPOTASSIUM_PHOSPHATE": {"weight": 0.14, "fert": "Монофосфат калия", "main_element": "P"}
-        }
-
-        # Коэффициенты распределения для кальциевой селитры
-        self.calcium_nitrate_ratios = {
-            "Ca": 0.7,  # 70% дефицита кальция покрываем кальциевой селитрой
-            "NO3": 0.2  # 30% дефицита NO3 покрываем кальциевой селитрой
-        }
-
-        # Расчёт соотношений азотов
-        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)
-
-    def _label(self, element):
-        """Форматирование названий элементов для вывода"""
-        labels = {
-            'N (NO3-)': 'NO3',
-            'N (NH4+)': 'NH4'
-        }
-        return labels.get(element, element)
-
+        
+    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)
+    
     def calculate(self):
-        """Основной метод расчета"""
-        try:
-            # 1. Вносим кальциевую селитру для Ca и частично для NO3
-            self._apply_calcium_nitrate()
-
-            # 2. Вносим аммонийный азот напрямую
-            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
-
-            # 3. Компенсируем остаток NO3 через калийную селитру
-            self._compensate_no3()
-
-            # 4. Компенсируем остальные элементы через веса компенсации
-            self._compensate_element("Mg")
-            self._compensate_element("P")
-            self._compensate_element("S")
-            self._compensate_element("K")
-
-            return self.results
-        except Exception as e:
-            print(f"Ошибка при расчёте: {str(e)}")
-            raise
-
-    def _apply_calcium_nitrate(self):
-        """Специальный метод для внесения кальциевой селитры"""
-        # Вносим кальций
-        ca_needed = self.target_profile['Ca'] - self.actual_profile.get('Ca', 0)
-        if ca_needed > 0.1:
-            ca_share = self.calcium_nitrate_ratios['Ca']
-            ca_to_apply = ca_needed * ca_share
-            self._apply("Кальциевая селитра", "Ca", ca_to_apply)
-
-        # Вносим часть NO3 из кальциевой селитры
-        no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile.get('N (NO3-)', 0)
-        if no3_needed > 0.1:
-            no3_share = self.calcium_nitrate_ratios['NO3']
-            no3_to_apply = no3_needed * no3_share
-            self._apply("Кальциевая селитра", "N (NO3-)", no3_to_apply)
-
-    def _compensate_no3(self):
-        """Компенсация остатка NO3 после внесения кальциевой селитры"""
-        no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile.get('N (NO3-)', 0)
-        if no3_needed > 0.1:
-            self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
-
-    def _compensate_element(self, element):
-        """Общий метод компенсации для других элементов"""
-        needed = self.target_profile[element] - self.actual_profile.get(element, 0)
-        if abs(needed) < 0.1:
-            return
-
-        candidates = []
-        for weight_key, weight_data in self.element_compensation_weights.items():
-            fert_name = weight_data["fert"]
-            if element in self.fertilizers.get(fert_name, {}):
-                candidates.append({
-                    'name': fert_name,
-                    'weight': weight_data["weight"],
-                    'content': self.fertilizers[fert_name][element]
-                })
-
-        if not candidates:
-            raise ValueError(f"Нет удобрений для элемента {element}")
-
-        total_weight = sum(c['weight'] for c in candidates)
-        for candidate in candidates:
-            share = candidate['weight'] / total_weight
-            ppm_to_apply = needed * share
-            self._apply(candidate['name'], element, ppm_to_apply)
-
-    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:
-                result = {
-                    'граммы': 0.0,
-                    'миллиграммы': 0,
-                    'вклад в 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(grams * 1000)
-
-            fert_ec = 0.0
-            for element, percent in self.fertilizers[fert_name].items():
-                added_ppm = (grams * percent * 1000) / self.volume
-                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:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
-            raise
-
-    def calculate_ec(self):
-        """Расчет общей электропроводности (EC)"""
-        return round(self.total_ec, 2)
-
+        # 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)
+            
+            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()]
+            }
+        return formatted
+    
     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" + "="*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" + "="*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ОСТАТОЧНЫЙ ДЕФИЦИТ:")
-            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
-
+            for el, val in self._prepare_results()['deficits'].items():
+                print(f"  {el}: {round(val, 1)} ppm")
+        else:
+            print("\nВсе элементы покрыты полностью")
 
+# Пример использования
 if __name__ == "__main__":
-    try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.calculate()
-        calculator.print_report()  # Правильный вызов метода класса
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
+    calc = NutrientCalculator(VOLUME_LITERS)
+    results = calc.calculate()
+    calc.print_report()