Update app.py

app.py

@@ -801,7 +801,7 @@ class NutrientCalculator:
         self.actual_profile = {k: 0.0 for k in self.target_profile}
         self.total_ec = 0.0
         self.fertilizers = {}
-        
+
         # Коэффициенты для расчета EC (мСм/см на ppm)
         self.ec_coefficients = {
             'P': 0.0012, 'K': 0.0018, 'Mg': 0.0015,
@@ -809,6 +809,13 @@ class NutrientCalculator:
             'N (NO3-)': 0.0017, 'N (NH4+)': 0.0019
         }
 
+        # Веса для компенсации (приоритеты)
+        self.compensation_weights = {
+            'Калий азотнокислый': {'weight': 0.5, 'main_elements': ['K', 'N (NO3-)']},
+            'Кальциевая селитра': {'weight': 0.3, 'main_elements': ['Ca', 'N (NO3-)']},
+            'Калий сернокислый': {'weight': 0.2, 'main_elements': ['K', 'S']}
+        }
+
     def _apply_fertilizer(self, fert_name: str, element: str, ppm: float):
         """Основной метод внесения удобрений с расчетом EC"""
         try:
@@ -830,11 +837,11 @@ class NutrientCalculator:
             self.results[fert_name]['граммы'] += grams
             self.results[fert_name]['миллиграммы'] = int(self.results[fert_name]['граммы'] * 1000)
             
-            # Обновляем все элементы из удобрения и рассчитываем EC
+            # Расчет EC и внесенных ppm
             fert_ec = 0.0
             for el, percent in self.fertilizers[fert_name].items():
                 added_ppm = (grams * percent * 1000) / self.volume
-                self.actual_profile[el] = self.actual_profile.get(el, 0) + added_ppm
+                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)
             
@@ -842,51 +849,61 @@ class NutrientCalculator:
             self.total_ec += fert_ec
 
         except KeyError as e:
-            raise ValueError(f"Неверный элемент или удобрение: {str(e)}")
+            raise ValueError(f"Ошибка в данных удобрений: {str(e)}")
 
     def calculate_ec(self) -> float:
-        """Расчет общей электропроводности"""
+        """Возвращает общую электропроводность (EC)"""
         return round(self.total_ec, 2)
 
+    def _compensate_element(self, element: str, needed_ppm: float):
+        """Компенсация дефицита элемента с учетом весов"""
+        suitable_ferts = [
+            (fert_name, fert_data) 
+            for fert_name, fert_data in self.fertilizers.items() 
+            if element in fert_data
+        ]
+        
+        if not suitable_ferts:
+            raise ValueError(f"Нет удобрений для элемента {element}")
+
+        # Сортировка по весам
+        suitable_ferts.sort(
+            key=lambda x: self.compensation_weights.get(x[0], {}).get('weight', 0.1),
+            reverse=True
+        )
+
+        remaining_ppm = needed_ppm
+        for fert_name, _ in suitable_ferts:
+            if remaining_ppm <= 0:
+                break
+            self._apply_fertilizer(fert_name, element, remaining_ppm)
+            remaining_ppm = self.target_profile[element] - self.actual_profile[element]
+
     def calculate(self) -> Dict[str, Any]:
-        """Основная логика расчёта"""
+        """Основной расчет питательного раствора"""
         try:
-            # 1. Вносим магний и серу
+            # 1. Вносим магний (сульфат магния)
             self._apply_fertilizer("Сульфат магния", "Mg", self.target_profile['Mg'])
             
             # 2. Вносим аммонийный азот
-            nh4_needed = self.target_profile['N (NH4+)'] - self.actual_profile['N (NH4+)']
-            if nh4_needed > 0:
-                self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)", nh4_needed)
+            self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)", self.target_profile['N (NH4+)'])
             
-            # 3. Вносим нитратный азот
-            no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
-            if no3_needed > 0:
-                # Через кальциевую селитру (если нужен кальций)
-                ca_needed = self.target_profile['Ca'] - self.actual_profile['Ca']
-                if ca_needed > 0:
-                    self._apply_fertilizer("Кальциевая селитра", "N (NO3-)", min(no3_needed, ca_needed/0.16972*0.11863))
-                
-                # Через калийную селитру (остаток)
-                remaining_no3 = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
-                if remaining_no3 > 0:
-                    self._apply_fertilizer("Калий азотнокислый", "N (NO3-)", remaining_no3)
+            # 3. Компенсируем нитратный азот
+            self._compensate_element("N (NO3-)", self.target_profile['N (NO3-)'])
             
             # 4. Вносим фосфор
             self._apply_fertilizer("Монофосфат калия", "P", self.target_profile['P'])
             
-            # 5. Корректируем калий
-            k_needed = self.target_profile['K'] - self.actual_profile['K']
-            if k_needed > 0:
-                self._apply_fertilizer("Калий сернокислый", "K", k_needed)
+            # 5. Компенсируем калий
+            self._compensate_element("K", self.target_profile['K'])
             
             return self._prepare_results()
-            
+
         except Exception as e:
-            raise RuntimeError(f"Ошибка расчёта: {str(e)}")
+            raise RuntimeError(f"Ошибка расчета: {str(e)}")
 
     def _prepare_results(self) -> Dict[str, Any]:
-        """Форматируем результаты для ответа в Flask"""
+        """Подготовка результатов для API"""
         return {
             'actual_profile': {k: round(v, 2) for k, v in self.actual_profile.items()},
             'fertilizers': {
@@ -903,17 +920,13 @@ class NutrientCalculator:
             'nitrogen_ratios': {
                 'NO3': round(self.target_profile['N (NO3-)'], 2),
                 'NH4': round(self.target_profile['N (NH4+)'], 2)
-            }
+            },
+            'compensation_weights': self.compensation_weights
         }
 
 
 
 
-
-
-
-
-
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try: