Update app.py

app.py

@@ -760,33 +760,68 @@ class NutrientCalculator:
     def __init__(self, volume_liters=1.0):
         self.volume = volume_liters
         self.results = {}
-        self.actual_profile = {}
-        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
 
-        # Инициализация весов компенсации
-        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.element_compensation_weights = {
+            "POTASSIUM_SULFATE": {"weight": 0.4, "fert": "Калий сернокислый", "main_element": "K"},
+            "MAGNESIUM_SULFATE": {"weight": 0.3, "fert": "Сульфат магния", "main_element": "Mg"},
+            "MONOPOTASSIUM_PHOSPHATE": {"weight": 0.2, "fert": "Монофосфат калия", "main_element": "P"}
         }
 
+        # Расчёт азота
+        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 calculate(self):
+        try:
+            # Вносим магний через компенсацию
+            self._compensate_element("Mg")
+
+            # Вносим кальций напрямую
+            self._apply("Кальциевая селитра", "Ca", self.target_profile['Ca'])
+
+            # Вносим фосфор через компенсацию
+            self._compensate_element("P")
+
+            # Вносим аммонийный азот напрямую
+            self._apply("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
+
+            # Компенсируем нитратный азот напрямую
+            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)
+
+            # Компенсируем серу через компенсацию
+            self._compensate_element("S")
+
+            # Компенсируем калий через компенсацию
+            self._compensate_element("K")
+
+            return self.results
+        except Exception as e:
+            print(f"Ошибка при расчёте: {str(e)}")
+            raise
+
     def _apply(self, fert_name, main_element, required_ppm):
         if required_ppm <= 0:
             return
 
         try:
-            content = self.fertilizers[fert_name].get(main_element, 0)
-            if content == 0:
-                raise KeyError(f"Элемент {main_element} отсутствует в удобрении {fert_name}")
-
+            content = self.fertilizers[fert_name][main_element]
             grams = (required_ppm * self.volume) / (content * 1000)
 
             if fert_name not in self.results:
@@ -800,28 +835,28 @@ class NutrientCalculator:
                 self.results[fert_name] = result
 
             self.results[fert_name]['граммы'] += grams
-            self.results[fert_name]['миллиграммы'] = int(grams * 1000)
+            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] = self.actual_profile.get(element, 0) + added_ppm
-                fert_ec += added_ppm * 0.0015  # Примерный коэффициент EC
+                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)}")
+            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
             raise
 
-    def _compensate_element(self, element, target_profile):
-        needed = target_profile[element] - self.actual_profile.get(element, 0)
+    def _compensate_element(self, element):
+        needed = self.target_profile[element] - self.actual_profile.get(element, 0)
         if needed <= 0:
             return
 
         candidates = []
-        for weight_key, weight_data in self.compensation_weights.items():
+        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({
@@ -839,93 +874,89 @@ class NutrientCalculator:
             ppm_to_apply = needed * share
             self._apply(candidate['name'], element, ppm_to_apply)
 
-    def calculate(self, target_profile):
-        try:
-            # Вносим магний
-            self._apply("Сульфат магния", "Mg", target_profile['Mg'])
-
-            # Вносим кальций через компенсацию
-            self._compensate_element("Ca", target_profile)
-
-            # Вносим фосфор
-            self._apply("Монофосфат калия", "P", target_profile['P'])
-
-            # Вносим аммонийный азот
-            self._apply("Аммоний азотнокислый", "N (NH4+)", target_profile['N (NH4+)'])
-
-            # Компенсируем нитратный азот
-            self._compensate_element("N (NO3-)", target_profile)
-
-            # Компенсируем серу
-            self._compensate_element("S", target_profile)
-
-            # Компенсируем калий
-            self._compensate_element("K", target_profile)
+    def calculate_ec(self):
+        return round(self.total_ec, 2)
 
-            return self.results
+    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ОСТАТОЧНЫЙ ДЕФИЦИТ:")
+            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)}")
+            print(f"Ошибка при выводе отчёта: {str(e)}")
             raise
 
 
 # Роут для обработки расчетов
+app = Flask(__name__)
+
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try:
         data = request.get_json()
 
         # Проверка обязательных полей
-        if not data or 'fertilizerConstants' not in data or 'profileSettings' not in data:
+        if not data or 'profileSettings' not in data:
             return jsonify({'error': 'Неверный формат данных'}), 400
 
         # Инициализация калькулятора
         calculator = NutrientCalculator(volume_liters=float(data['profileSettings'].get('liters', 100)))
 
-        # Настройка удобрений из запроса
-        calculator.fertilizers = {
-            "Кальциевая селитра": {
-                "N (NO3-)": float(data['fertilizerConstants']["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
-                "Ca": float(data['fertilizerConstants']["Кальциевая селитра"].get("Ca", 0.16972))
-            },
-            "Калий азот��окислый": {
-                "N (NO3-)": float(data['fertilizerConstants']["Калий азотнокислый"].get("N (NO3-)", 0.136)),
-                "K": float(data['fertilizerConstants']["Калий азотнокислый"].get("K", 0.382))
-            },
-            "Аммоний азотнокислый": {
-                "N (NO3-)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
-                "N (NH4+)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
-            },
-            "Сульфат магния": {
-                "Mg": float(data['fertilizerConstants']["Сульфат магния"].get("Mg", 0.09861)),
-                "S": float(data['fertilizerConstants']["Сульфат магния"].get("S", 0.13010))
-            },
-            "Монофосфат калия": {
-                "P": float(data['fertilizerConstants']["Монофосфат калия"].get("P", 0.218)),
-                "K": float(data['fertilizerConstants']["Монофосфат калия"].get("K", 0.275))
-            },
-            "Калий сернокислый": {
-                "K": float(data['fertilizerConstants']["Калий сернокислый"].get("K", 0.44874)),
-                "S": float(data['fertilizerConstants']["Калий сернокислый"].get("S", 0.18401))
-            }
-        }
-
         # Настройка целевого профиля
-        total_n = float(data['profileSettings'].get('TOTAL_NITROGEN', 125.0))
-        no3_ratio = float(data['profileSettings'].get('NO3_RATIO', 8.25))
-        nh4_ratio = 1.0
-
-        target_profile = {
+        calculator.target_profile = {
             'P': float(data['profileSettings'].get('P', 31.0)),
             'K': float(data['profileSettings'].get('K', 210.0)),
             'Mg': float(data['profileSettings'].get('Mg', 24.0)),
             'Ca': float(data['profileSettings'].get('Ca', 84.0)),
             'S': float(data['profileSettings'].get('S', 56.439)),
-            'N (NO3-)': total_n * (no3_ratio / (no3_ratio + nh4_ratio)),
-            'N (NH4+)': total_n * (nh4_ratio / (no3_ratio + nh4_ratio))
+            'N (NO3-)': 0.0,
+            'N (NH4+)': 0.0
         }
 
+        total_n = float(data['profileSettings'].get('TOTAL_NITROGEN', 125.0))
+        no3_ratio = float(data['profileSettings'].get('NO3_RATIO', 8.25))
+        nh4_ratio = 1.0
+
+        total_parts = no3_ratio + nh4_ratio
+        calculator.target_profile['N (NO3-)'] = total_n * (no3_ratio / total_parts)
+        calculator.target_profile['N (NH4+)'] = total_n * (nh4_ratio / total_parts)
+
         # Выполнение расчета
-        results = calculator.calculate(target_profile)
+        results = calculator.calculate()
 
         # Подготовка ответа
         response = {
@@ -936,7 +967,7 @@ def handle_calculation():
                 "NO3_RATIO": no3_ratio,
                 "TOTAL_NITROGEN": total_n
             },
-            "total_ec": round(calculator.total_ec, 2),
+            "total_ec": calculator.calculate_ec(),
             "total_ppm": round(sum(calculator.actual_profile.values()), 3)
         }