Update app.py

app.py

@@ -686,172 +686,204 @@ def nutri_call():
 
 
 
+from tabulate import tabulate
+
+# Константы
+TOTAL_NITROGEN = 125.000
+NO3_RATIO = 8.84
+NH4_RATIO = 1.00
+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
+}
+
+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}
+}
+
 class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         self.results = {}
-        self.target = {
-            'P': 0, 'K': 0, 'Mg': 0, 'Ca': 0, 'S': 0,
-            'NO3': 0, 'NH4': 0
-        }
-        self.actual = {
-            'P': 0.0, 'K': 0.0, 'Mg': 0.0, 'Ca': 0.0, 'S': 0.0,
-            'NO3': 0.0, 'NH4': 0.0
-        }
-        self.fertilizers = {}
+        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
 
-    def set_target_profile(self, profile_data):
-        self.target.update({
-            'P': float(profile_data.get('P', 0)),
-            'K': float(profile_data.get('K', 0)),
-            'Mg': float(profile_data.get('Mg', 0)),
-            'Ca': float(profile_data.get('Ca', 0)),
-            'S': float(profile_data.get('S', 0)),
-            'NO3': float(profile_data.get('N (NO3-)', 0)),
-            'NH4': float(profile_data.get('N (NH4+)', 0))
-        })
-
-    def set_fertilizers(self, fertilizers_data):
-        self.fertilizers = {
-            "Сульфат магния": {
-                "Mg": float(fertilizers_data["Сульфат магния"]["Mg"]),
-                "S": float(fertilizers_data["Сульфат магния"]["S"])
-            },
-            "Кальциевая селитра": {
-                "NO3": float(fertilizers_data["Кальциевая селитра"]["N (NO3-)"]),
-                "Ca": float(fertilizers_data["Кальциевая селитра"]["Ca"])
-            },
-            "Монофосфат калия": {
-                "P": float(fertilizers_data["Монофосфат калия"]["P"]),
-                "K": float(fertilizers_data["Монофосфат калия"]["K"])
-            },
-            "Аммоний азотнокислый": {
-                "NO3": float(fertilizers_data["Аммоний азотнокислый"]["N (NO3-)"]),
-                "NH4": float(fertilizers_data["Аммоний азотнокислый"]["N (NH4+)"])
-            },
-            "Калий азотнокислый": {
-                "NO3": float(fertilizers_data["Калий азотнокислый"]["N (NO3-)"]),
-                "K": float(fertilizers_data["Калий азотнокислый"]["K"])
-            },
-            "Калий сернокислый": {
-                "K": float(fertilizers_data["Калий сернокислый"]["K"]),
-                "S": float(fertilizers_data["Калий сернокислый"]["S"])
-            }
+        # Расчёт азота
+        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 _label(self, element):
+        """Форматирование названий элементов для вывода"""
+        labels = {
+            'N (NO3-)': 'NO3',
+            'N (NH4+)': 'NH4'
         }
+        return labels.get(element, element)
 
     def calculate(self):
         try:
-            # 1. Вносим обязательные компоненты
-            self._apply_fertilizer("Сульфат магния", "Mg")
-            self._apply_fertilizer("Монофосфат калия", "P")
+            self._apply("Сульфат магния", "Mg", self.target_profile['Mg'])
+            self._apply("Кальциевая селитра", "Ca", self.target_profile['Ca'])
+            self._apply("Монофосфат калия", "P", self.target_profile['P'])
+            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
             
-            # 2. Контроль азота
-            self._apply_fertilizer("Аммоний азотнокислый", "NH4")
+            current_no3 = self.actual_profile['N (NO3-)']
+            no3_needed = self.target_profile['N (NO3-)'] - current_no3
             
-            # 3. Кальций с контролем NO3
-            remaining_no3 = max(self.target['NO3'] - self.actual['NO3'], 0)
-            if remaining_no3 > 0.1:
-                self._apply_fertilizer("Кальциевая селитра", "Ca", 
-                                      min(self.target['Ca'] - self.actual['Ca'], 
-                                      remaining_no3 / 0.11863 * 0.16972))
+            if no3_needed > 0.1:
+                self._apply("Калий азотнокислый", "N (NO3-)", no3_needed)
             
-            # 4. Довносим кальций если остался дефицит
-            ca_deficit = self.target['Ca'] - self.actual['Ca']
-            if ca_deficit > 0.1:
-                self._apply_fertilizer("Кальциевая селитра", "Ca")
+            self._apply_k_sulfate()
             
-            # 5. Калий с минимальным NO3
-            k_deficit = self.target['K'] - self.actual['K']
+            k_deficit = self.target_profile['K'] - self.actual_profile['K']
             if k_deficit > 0.1:
-                if self.actual['NO3'] < self.target['NO3']:
-                    self._apply_fertilizer("Калий азотнокислый", "K")
-                else:
-                    self._apply_fertilizer("Калий сернокислый", "K")
+                self._apply("Калий азотнокислый", "K", k_deficit)
             
-            # 6. Сера
-            s_deficit = self.target['S'] - self.actual['S']
-            if s_deficit > 0.1:
-                self._apply_fertilizer("Калий сернокислый", "S")
-            
-            return True
+            return self.results
         except Exception as e:
-            print(f"Calculation error: {str(e)}")
-            return False
-
-    def _apply_fertilizer(self, name, main_element, required_ppm=None):
-        if name not in self.fertilizers:
-            return
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
 
-        if required_ppm is None:
-            required_ppm = self.target[main_element] - self.actual[main_element]
-        
+    def _apply(self, fert_name, main_element, required_ppm):
         if required_ppm <= 0:
             return
-
-        content = self.fertilizers[name].get(main_element, 0)
-        if content <= 0:
+            
+        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 _apply_k_sulfate(self):
+        fert = "Калий сернокислый"
+        k_def = self.target_profile['K'] - self.actual_profile['K']
+        s_def = self.target_profile['S'] - self.actual_profile['S']
+        
+        if k_def <= 0 and s_def <= 0:
             return
+            
+        try:
+            if s_def > 0.1:
+                s_content = self.fertilizers[fert]["S"]
+                grams_s = (s_def * self.volume) / (s_content * 1000)
+                
+                k_content = self.fertilizers[fert]["K"]
+                k_from_s = (grams_s * k_content * 1000) / self.volume
+                
+                if k_from_s > k_def and k_def > 0.1:
+                    grams = (k_def * self.volume) / (k_content * 1000)
+                else:
+                    grams = grams_s
+                    
+                self._apply(fert, "S", s_def)
+        except Exception as e:
+            print(f"Ошибка при расч��те сульфата калия: {str(e)}")
+            raise
 
-        grams = (required_ppm * self.volume) / (content * 1000)
-
-        # Инициализация записи
-        if name not in self.results:
-            self.results[name] = {'grams': 0.0, 'adds': {}}
-        
-        # Обновление данных
-        self.results[name]['grams'] += grams
-        for element, percent in self.fertilizers[name].items():
-            added_ppm = (grams * percent * 1000) / self.volume
-            self.actual[element] += added_ppm
-            if element not in self.results[name]['adds']:
-                self.results[name]['adds'][element] = 0.0
-            self.results[name]['adds'][element] += added_ppm
-
-        # Расчёт EC
-        ec_coeff = {
-            'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015,
-            'Ca': 0.0016, 'S': 0.0014,
-            'NO3': 0.0017, 'NH4': 0.0019
-        }
-        self.total_ec += sum(
-            added_ppm * ec_coeff.get(elem, 0.0015)
-            for elem, added_ppm in self.results[name]['adds'].items()
-        )
+    def calculate_ec(self):
+        return round(self.total_ec, 2)
 
-    def get_results(self):
-        return {
-            'fertilizers': [
-                {
-                    'name': name,
-                    'grams': round(data['grams'], 3),
-                    'adds': {k: round(v, 3) for k, v in data['adds'].items()}
-                } for name, data in self.results.items()
-            ],
-            'profile': [
-                {'element': 'P', 'ppm': round(self.actual['P'], 3)},
-                {'element': 'K', 'ppm': round(self.actual['K'], 3)},
-                {'element': 'Mg', 'ppm': round(self.actual['Mg'], 3)},
-                {'element': 'Ca', 'ppm': round(self.actual['Ca'], 3)},
-                {'element': 'S', 'ppm': round(self.actual['S'], 3)},
-                {'element': 'N-NO3', 'ppm': round(self.actual['NO3'], 3)},
-                {'element': 'N-NH4', 'ppm': round(self.actual['NH4'], 3)}
-            ],
-            'ec': round(self.total_ec, 2),
-            'deficits': {
-                'Ca': max(self.target['Ca'] - self.actual['Ca'], 0),
-                'K': max(self.target['K'] - self.actual['K'], 0),
-                'Mg': max(self.target['Mg'] - self.actual['Mg'], 0),
-                'N (NH4+)': max(self.target['NH4'] - self.actual['NH4'], 0),
-                'N (NO3-)': max(self.target['NO3'] - self.actual['NO3'], 0),
-                'P': max(self.target['P'] - self.actual['P'], 0),
-                'S': max(self.target['S'] - self.actual['S'], 0)
+    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:
+        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
+        calculator.calculate()
+        calculator.print_report()  # Правильный вызов метода класса
+    except Exception as e:
+        print(f"Критическая ошибка: {str(e)}")