Update app.py

app.py

@@ -692,21 +692,30 @@ def nutri_call():
 
 
 
+
+
+
+
+
+
+
+
+
+
 from tabulate import tabulate
-import numpy as np
 
 # Глобальные параметры
-TOTAL_NITROGEN = 120.0  # Общее количество азота
+TOTAL_NITROGEN = 120.0 # Общее количество азота
 NO3_RATIO = 8.0         # Соотношение NO3:NH4
-NH4_RATIO = 1.0         # Соотношение NH4:NO3
-VOLUME_LITERS = 100     # Объем раствора
+NH4_RATIO = 1.00          # Соотношение NH4:NO3
+VOLUME_LITERS = 100       # Объем раствора
 
 BASE_PROFILE = {
     "P": 50,      # Фосфор
-    "K": 210,     # Калий
+    "K": 300,     # Калий
     "Mg": 120,    # Магний (высокий уровень)
     "Ca": 150,    # Кальций
-    "S": 50,      # Сера
+    "S": 100,     # Сера
     "N (NO3-)": 0,  # Рассчитывается автоматически
     "N (NH4+)": 0   # Рассчитывается автоматически
 }
@@ -718,172 +727,210 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
     "Аммоний азотнокислый": {"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},
-    "Кольцевая селитра": {"N (NO3-)": 0.15, "Ca": 0.20}  # Новое удобрение
+    "Сульфат кальция": {"Ca": 0.23, "S": 0.186}
 }
 
 EC_COEFFICIENTS = {
-    'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015,
-    'Ca': 0.0016, 'S': 0.0014,
+    '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):
+    def __init__(self, volume_liters=1.0, profile=BASE_PROFILE):
         self.volume = volume_liters
-        self.target_profile = BASE_PROFILE.copy()
-        self._init_nitrogen()
-        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
         self.results = {}
+        self.target_profile = profile.copy()
         self.actual_profile = {k: 0.0 for k in self.target_profile}
+        self.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS 
         self.total_ec = 0.0
-        self.tolerance = 1.0  # Допустимое отклонение в ppm
-        self.max_iterations = 100  # Максимальное число итераций
+
+        # Расчёт азота
+        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+)']
+        }
+
+        # Веса компенсации
+        self.compensation_weights = {
+            "Ca": {"weight": 0.3, "fert": "Сульфат кальция", "main_element": "Ca"},
+            "K": {"weight": 0.2, "fert": "Калий азотнокислый", "main_element": "K"},
+            "Mg": {"weight": 0.2, "fert": "Сульфат магния", "main_element": "Mg"},
+            "P": {"weight": 0.1, "fert": "Монофосфат калия", "main_element": "P"},
+            "S": {"weight": 0.1, "fert": "Калий сернокислый", "main_element": "S"},
+            "N (NO3-)": {"weight": 0.05, "fert": "Калий азотнокислый", "main_element": "N (NO3-)"},
+            "N (NH4+)": {"weight": 0.05, "fert": "Аммоний азотнокислый", "main_element": "N (NH4+)"}
+        }
+
+    def _label(self, element):
+        """Форматирование названий элементов для вывода"""
+        labels = {
+            'N (NO3-)': 'NO3',
+            'N (NH4+)': 'NH4'
+        }
+        return labels.get(element, element)
 
     def calculate(self):
-        # Оптимизированный порядок внесения элементов
-        priority_order = [
-            ('Ca', ['Кальциевая селитра', 'Сульфат кальция']),
-            ('N (NH4+)', ['Аммоний азотнокислый']),
-            ('P', ['Монофосфат калия']),
-            ('Mg', ['Сульфат магния']),
-            ('N (NO3-)', ['Калий азотнокислый', 'Кальциевая селитра']),
-            ('K', ['Калий азотнокислый', 'Калий сернокислый']),
-            ('S', ['Калий сернокислый', 'Сульфат магния'])
-        ]
-
-        for _ in range(self.max_iterations):
-            for element, fert_options in priority_order:
-                self._balance_element(element, fert_options)
-            
-            if self._is_balanced():
-                break
-        
-        # Финальная тонкая настройка
-        self._fine_tune()
-        
-        return self._prepare_results()
+        try:
+            # Первый проход: компенсация основных элементов
+            self._compensate_main_elements()
+
+            # Второй проход: компенсация азота
+            self._compensate_nitrogen()
 
-    def _balance_element(self, element, fert_options):
-        deficit = self.target_profile[element] - self.actual_profile[element]
-        if deficit <= self.tolerance:
+            # Третий проход: компенсация второстепенных элементов
+            self._compensate_secondary_elements()
+
+            # Четвертый проход: корректировка перебора
+            self._adjust_overages()
+
+            return self.results
+        except Exception as e:
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
+
+    def _compensate_main_elements(self):
+        """Компенсация основных элементов (Ca, Mg, P)"""
+        for element, weight_data in self.compensation_weights.items():
+            if element in ["Ca", "Mg", "P"]:
+                fert_name = weight_data["fert"]
+                main_element = weight_data["main_element"]
+                required_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
+                if required_ppm > 0.1:
+                    self._apply_with_limit(fert_name, main_element, required_ppm)
+
+    def _compensate_nitrogen(self):
+        """Компенсация азота (NO3-, NH4+)"""
+        for nitrogen_type in ["N (NO3-)", "N (NH4+)"]:
+            required_ppm = self.target_profile[nitrogen_type] - self.actual_profile[nitrogen_type]
+            if required_ppm > 0.1:
+                fert_name = self.compensation_weights[nitrogen_type]["fert"]
+                self._apply_with_limit(fert_name, nitrogen_type, required_ppm)
+
+    def _compensate_secondary_elements(self):
+        """Компенсация второстепенных элементов (K, S)"""
+        for element, weight_data in self.compensation_weights.items():
+            if element in ["K", "S"]:
+                fert_name = weight_data["fert"]
+                main_element = weight_data["main_element"]
+                required_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
+                if required_ppm > 0.1:
+                    self._apply_with_limit(fert_name, main_element, required_ppm)
+
+    def _apply_with_limit(self, fert_name, main_element, required_ppm):
+        """Применение удобрения с ограничением по перебору"""
+        if required_ppm <= 0:
             return
+
+        try:
+            content = self.fertilizers[fert_name][main_element]
+            max_allowed_ppm = self.target_profile[main_element] - self.actual_profile[main_element]
+            grams = min((required_ppm * self.volume) / (content * 1000), (max_allowed_ppm * self.volume) / (content * 1000))
             
-        for fert_name in fert_options:
-                content = self.fertilizers[fert_name].get(element, 0)
-                if content == 0:
-                    continue
-                    
-                # Рассчитываем возможное количество без перебора других элементов
-                max_possible = min(
-                    deficit / content,
-                    *[(self.target_profile[e] - self.actual_profile[e]) / self.fertilizers[fert_name].get(e, 1)
-                      for e in self.fertilizers[fert_name] if e != element]
-                )
+            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
                 
-                if max_possible > 0:
-                    grams = (max_possible * 1000) / self.volume
-                    self._apply_fertilizer(fert_name, grams)
-                    break
-
-    def _fine_tune(self):
-        # Тонкая подстройка малыми шагами (0.1 грамма)
-        for _ in range(20):
-            worst_element = max(
-                self.target_profile.keys(),
-                key=lambda x: abs(self.target_profile[x] - self.actual_profile[x])
-            )
-            deficit = self.target_profile[worst_element] - self.actual_profile[worst_element]
+            self.results[fert_name]['граммы'] += grams
+            self.results[fert_name]['миллиграммы'] += int(grams * 1000)
             
-            if abs(deficit) <= self.tolerance:
-                break
-                
-            # Ищем уд��брение, содержащее этот элемент
-            for fert_name, contents in self.fertilizers.items():
-                if worst_element in contents:
-                    small_step = 0.1  # грамм
-                    self._apply_fertilizer(fert_name, small_step)
-                    break
-
-    def _is_balanced(self):
-        return all(
-            abs(self.target_profile[e] - self.actual_profile[e]) <= self.tolerance
-            for e in self.target_profile
-        )
-
-    def _apply_fertilizer(self, fert_name, grams):
-        if fert_name not in self.results:
-            self.results[fert_name] = {
-                'граммы': 0.0,
-                'вклад': {e: 0.0 for e in self.fertilizers[fert_name]}
-            }
-        
-        self.results[fert_name]['граммы'] += grams
-        
-        for element, content in self.fertilizers[fert_name].items():
-            added_ppm = (grams * content * 1000) / self.volume
-            self.actual_profile[element] += added_ppm
-            self.results[fert_name]['вклад'][element] += added_ppm
-            self.total_ec += added_ppm * EC_COEFFICIENTS.get(element, 0.0015)
-
-    def _fine_tuning(self):
-        # Тонкая подстройка малыми шагами (0.1 грамма)
-        for _ in range(100):  # Максимум 100 итераций
-            worst_element = self._get_worst_balanced()
-            if not worst_element:
-                break
-                
-            self._balance_element(worst_element)
-
-    def _get_worst_balanced(self):
-        worst_element = None
-        max_diff = 0
-        
-        for element in self.target_profile:
-            diff = abs(self.target_profile[element] - self.actual_profile[element])
-            if diff > max_diff and diff > self.tolerance:
-                max_diff = diff
-                worst_element = element
+            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)
                 
-        return worst_element
+            self.results[fert_name]['вклад в EC'] += fert_ec
+            self.total_ec += fert_ec
+        except KeyError as e:
+            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
+            raise
 
-    def _prepare_results(self):
-        deficits = {
-            k: round(self.target_profile[k] - self.actual_profile[k], 3)
-            for k in self.target_profile 
-            if abs(self.target_profile[k] - self.actual_profile[k]) > self.tolerance
-        }
-        
-        return {
-            "actual_profile": {k: round(v, 3) for k, v in self.actual_profile.items()},
-            "fertilizers": self._format_fertilizers(),
-            "total_ec": round(self.total_ec, 3),
-            "total_ppm": round(sum(self.actual_profile.values()), 3),
-            "deficits": deficits
-        }
+    def _adjust_overages(self):
+        """Корректировка перебора элементов"""
+        for element in self.actual_profile:
+            if self.actual_profile[element] > self.target_profile[element]:
+                overage = self.actual_profile[element] - self.target_profile[element]
+                self.actual_profile[element] -= overage
+                print(f"Корректировка перебора: {element} уменьшен на {overage:.2f} ppm")
 
-    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_COEFFICIENTS.get(k, 0.0015) 
-                    for k, v in data['вклад'].items()
-                ), 3),
-                'добавит': [f"{k}: {round(v, 3)} ppm" for k, v in data['вклад'].items()]
-            }
-        return formatted
+    def calculate_ec(self):
+        return round(self.total_ec, 2)
 
-    def generate_report(self):
-        """Генерация отчета о питательном растворе"""
+    def print_initial_nitrogen_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
+            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:
+        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
+        calculator.calculate()
+        calculator.print_report()  # Правильный вызов метода класса
+    except Exception as e:
+        print(f"Критическая ошибка: {str(e)}")