Update app.py

app.py

@@ -802,131 +802,109 @@ class NutrientCalculator:
         self.total_ec = 0.0
         self.fertilizers = {}
         
-        # Веса для компенсации (приоритеты)
-        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'}
+        # Коэффициенты для расчета EC (мСм/см на ppm)
+        self.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
         }
 
     def _apply_fertilizer(self, fert_name: str, element: str, ppm: float):
-        """Основной метод внесения удобрений"""
+        """Основной метод внесения удобрений с расчетом EC"""
         try:
             if ppm <= 0:
                 return
 
             content = self.fertilizers[fert_name][element]
             grams = (ppm * self.volume) / (content * 1000)
+            milligrams = grams * 1000
             
             if fert_name not in self.results:
                 self.results[fert_name] = {
-                    'grams': 0.0,
-                    'ppm_added': {}
+                    'граммы': 0.0,
+                    'миллиграммы': 0,
+                    'вклад в EC': 0.0,
+                    'внесенные ppm': {}
                 }
 
-            self.results[fert_name]['grams'] += grams
+            self.results[fert_name]['граммы'] += grams
+            self.results[fert_name]['миллиграммы'] = int(self.results[fert_name]['граммы'] * 1000)
             
-            # Обновляем все элементы из удобрения
+            # Обновляем все элементы из удобрения и рассчитываем EC
+            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.results[fert_name]['ppm_added'][el] = self.results[fert_name]['ppm_added'].get(el, 0) + 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)
+            
+            self.results[fert_name]['вклад в EC'] += fert_ec
+            self.total_ec += fert_ec
 
         except KeyError as e:
             raise ValueError(f"Неверный элемент или удобрение: {str(e)}")
 
-    def _compensate_with_weights(self, element: str, needed_ppm: float):
-        """Компенсация с учётом весов"""
-        candidates = []
-        
-        # Ищем все удобрения, которые содержат нужный элемент
-        for fert_name, fert_data in self.fertilizers.items():
-            if element in fert_data:
-                # Находим соответствующий вес в compensation_weights
-                weight = 0.0
-                for comp_key, comp_data in self.compensation_weights.items():
-                    if comp_data['fert'] == fert_name and comp_data['main_element'] == element:
-                        weight = comp_data['weight']
-                        break
-                
-                candidates.append({
-                    'fert_name': fert_name,
-                    'element': element,
-                    'weight': weight,
-                    'content': fert_data[element]
-                })
-        
-        if not candidates:
-            raise ValueError(f"No fertilizers found to compensate {element}")
-        
-        # Сортируем по весу (больший вес = выше приоритет)
-        candidates.sort(key=lambda x: x['weight'], reverse=True)
-        
-        # Применяем удобрения по порядку, пока не компенсируем дефицит
-        remaining_ppm = needed_ppm
-        for candidate in candidates:
-            if remaining_ppm <= 0:
-                break
-                
-            # Рассчитываем сколько можем внести этим удобрением
-            max_possible = remaining_ppm / candidate['weight'] if candidate['weight'] > 0 else remaining_ppm
-            to_apply = min(max_possible, remaining_ppm)
-            
-            self._apply_fertilizer(candidate['fert_name'], candidate['element'], to_apply)
-            remaining_ppm -= to_apply
+    def calculate_ec(self) -> float:
+        """Расчет общей электропроводности"""
+        return round(self.total_ec, 2)
 
-    def calculate(self):
-        """Основная логика расчёта с компенсационными весами"""
+    def calculate(self) -> Dict[str, Any]:
+        """Основная логика расчёта"""
         try:
-            # 1. Вносим магний и серу (без компенсации)
+            # 1. Вносим магний и серу
             self._apply_fertilizer("Сульфат магния", "Mg", self.target_profile['Mg'])
             
-            # 2. Вносим аммонийный азот (без компенсации)
+            # 2. Вносим аммонийный азот
             nh4_needed = self.target_profile['N (NH4+)'] - self.actual_profile['N (NH4+)']
             if nh4_needed > 0:
                 self._apply_fertilizer("Аммоний азотнокислый", "N (NH4+)", nh4_needed)
             
-            # 3. Вносим нитратный азот с компенсацией
+            # 3. Вносим нитратный азот
             no3_needed = self.target_profile['N (NO3-)'] - self.actual_profile['N (NO3-)']
             if no3_needed > 0:
-                self._compensate_with_weights("N (NO3-)", no3_needed)
+                # Через кальциевую селитру (если нужен кальций)
+                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)
             
-            # 4. Вносим фосфор (без компенсации)
+            # 4. Вносим фосфор
             self._apply_fertilizer("Монофосфат калия", "P", self.target_profile['P'])
             
-            # 5. Корректируем калий с компенсацией
+            # 5. Корректируем калий
             k_needed = self.target_profile['K'] - self.actual_profile['K']
             if k_needed > 0:
-                self._compensate_with_weights("K", k_needed)
+                self._apply_fertilizer("Калий сернокислый", "K", k_needed)
             
             return self._prepare_results()
             
         except Exception as e:
             raise RuntimeError(f"Ошибка расчёта: {str(e)}")
 
-    def _prepare_results(self):
-        """Форматируем результаты для ответа"""
+    def _prepare_results(self) -> Dict[str, Any]:
+        """Форматируем результаты для ответа в Flask"""
         return {
-            'profile': self.actual_profile,
-            'fertilizers': self.results,
-            'stats': {
-                'total_ppm': sum(self.actual_profile.values()),
-                'nitrogen_ratio': {
-                    'NO3': self.target_profile['N (NO3-)'],
-                    'NH4': self.target_profile['N (NH4+)']
-                },
-                'compensation_weights_used': self.compensation_weights
+            'actual_profile': {k: round(v, 2) for k, v in self.actual_profile.items()},
+            'fertilizers': {
+                fert: {
+                    'граммы': round(data['граммы'], 3),
+                    'миллиграммы': data['миллиграммы'],
+                    'вклад в EC': round(data['вклад в EC'], 3),
+                    'внесенные ppm': {k: round(v, 2) for k, v in data['внесенные ppm'].items()}
+                }
+                for fert, data in self.results.items()
+            },
+            'total_ec': self.calculate_ec(),
+            'total_ppm': round(sum(self.actual_profile.values()), 2),
+            'nitrogen_ratios': {
+                'NO3': round(self.target_profile['N (NO3-)'], 2),
+                'NH4': round(self.target_profile['N (NH4+)'], 2)
             }
         }
-if __name__ == "__main__":
-    try:
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.calculate()
-        calculator.print_report()  # Правильный вызов метода класса
-    except Exception as e:
-        print(f"Критическая ошибка: {str(e)}")
-
-
 
 
 
@@ -936,117 +914,84 @@ if __name__ == "__main__":
 
 
 
-from flask import request, jsonify
-
-def round_floats(obj, ndigits=3):
-    """Рекурсивно округляет все float значения в структуре данных"""
-    if isinstance(obj, float):
-        return round(obj, ndigits)
-    elif isinstance(obj, dict):
-        return {k: round_floats(v, ndigits) for k, v in obj.items()}
-    elif isinstance(obj, (list, tuple)):
-        return [round_floats(x, ndigits) for x in obj]
-    return obj
-
 @app.route('/calculation', methods=['POST'])
 def handle_calculation():
     try:
         data = request.get_json()
         
-        # Получаем параметр точности округления (по умолчанию 3)
-        rounding_precision = int(data['profileSettings'].get('rounding_precision', 3))
-        
         # Проверка обязательных полей
         if not data or 'fertilizerConstants' not in data or 'profileSettings' not in data:
             return jsonify({'error': 'Неверный формат данных'}), 400
         
-        # Извлекаем данные из запроса
-        fertilizer_data = data['fertilizerConstants']
-        profile_data = data['profileSettings']
-        
-        # Устанавливаем константы из запроса
-        TOTAL_NITROGEN = float(profile_data.get('TOTAL_NITROG', 125.0))
-        NO3_RATIO = float(profile_data.get('NO3_RAT', 8.25))
-        VOLUME_LITERS = float(profile_data.get('liters', 100))
-        NH4_RATIO = 1.00  # Фиксированное значение
-        
-        # Формируем целевой профиль
-        target_profile = {
-            'P': float(profile_data.get('P', 31.0)),
-            'K': float(profile_data.get('K', 210.0)),
-            'Mg': float(profile_data.get('Mg', 24.0)),
-            'Ca': float(profile_data.get('Ca', 84.0)),
-            'S': float(profile_data.get('S', 56.439)),
-            'N (NO3-)': 0,  # Будет рассчитано в калькуляторе
-            'N (NH4+)': 0   # Будет рассчитано в калькуляторе
-        }
+        # Инициализация калькулятора
+        calculator = NutrientCalculator(volume_liters=float(data['profileSettings'].get('liters', 100)))
         
-        # Обновляем константы удобрений
-        NUTRIENT_CONTENT_IN_FERTILIZERS = {
+        # Настройка удобрений из запроса
+        calculator.fertilizers = {
             "Кальциевая селитра": {
-                "N (NO3-)": float(fertilizer_data["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
-                "Ca": float(fertilizer_data["Кальциевая селитра"].get("Ca", 0.16972))
+                "N (NO3-)": float(data['fertilizerConstants']["Кальциевая селитра"].get("N (NO3-)", 0.11863)),
+                "Ca": float(data['fertilizerConstants']["Кальциевая селитра"].get("Ca", 0.16972))
             },
             "Калий азотнокислый": {
-                "N (NO3-)": float(fertilizer_data["Калий азотнокислый"].get("N (NO3-)", 0.13854)),
-                "K": float(fertilizer_data["Калий азотнокислый"].get("K", 0.36672))
+                "N (NO3-)": float(data['fertilizerConstants']["Калий азотнокислый"].get("N (NO3-)", 0.136)),
+                "K": float(data['fertilizerConstants']["Калий азотнокислый"].get("K", 0.382))
             },
             "Аммоний азотнокислый": {
-                "N (NO3-)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
-                "N (NH4+)": float(fertilizer_data["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
+                "N (NO3-)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NO3-)", 0.17499)),
+                "N (NH4+)": float(data['fertilizerConstants']["Аммоний азотнокислый"].get("N (NH4+)", 0.17499))
             },
             "Сульфат магния": {
-                "Mg": float(fertilizer_data["Сульфат магния"].get("Mg", 0.1022)),
-                "S": float(fertilizer_data["Сульфат магния"].get("S", 0.13483))
+                "Mg": float(data['fertilizerConstants']["Сульфат магния"].get("Mg", 0.09861)),
+                "S": float(data['fertilizerConstants']["Сульфат магния"].get("S", 0.13010))
             },
             "Монофосфат калия": {
-                "P": float(fertilizer_data["Монофосфат калия"].get("P", 0.22761)),
-                "K": float(fertilizer_data["Монофосфат калия"].get("K", 0.28731))
+                "P": float(data['fertilizerConstants']["Монофосфат калия"].get("P", 0.218)),
+                "K": float(data['fertilizerConstants']["Монофосфат калия"].get("K", 0.275))
             },
             "Калий сернокислый": {
-                "K": float(fertilizer_data["Калий сернокислый"].get("K", 0.44874)),
-                "S": float(fertilizer_data["Калий сернокислый"].get("S", 0.18401))
+                "K": float(data['fertilizerConstants']["Калий сернокислый"].get("K", 0.44874)),
+                "S": float(data['fertilizerConstants']["Калий сернокислый"].get("S", 0.18401))
             }
         }
         
-        # Создаем и настраиваем калькулятор
-        calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)
-        calculator.target_profile = target_profile
-        calculator.fertilizers = NUTRIENT_CONTENT_IN_FERTILIZERS
-        
-        # Устанавливаем параметры азота
-        calculator.target_profile['N (NO3-)'] = TOTAL_NITROGEN * (NO3_RATIO / (NO3_RATIO + NH4_RATIO))
-        calculator.target_profile['N (NH4+)'] = TOTAL_NITROGEN * (NH4_RATIO / (NO3_RATIO + NH4_RATIO))
-        
-        # Выполняем расчет
-        results = calculator.calculate()
-        
-        # Формируем ответ
-        response = {
-            'actual_profile': calculator.actual_profile,
-            'fertilizers': results,
-            'total_ec': calculator.calculate_ec(),
-            'total_ppm': sum(calculator.actual_profile.values()),
-            'nitrogen_ratios': {
-                'NO3_RATIO': NO3_RATIO,
-                'NH4_RATIO': NH4_RATIO,
-                'TOTAL_NITROGEN': TOTAL_NITROGEN
-            }
+        # Настройка целевого профиля
+        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-)': 0.0,
+            'N (NH4+)': 0.0
         }
         
-        # Округляем все числовые значения
-        rounded_response = round_floats(response, rounding_precision)
+        # Установка параметров азота
+        total_n = float(data['profileSettings'].get('TOTAL_NITROGEN', 125.0))
+        no3_ratio = float(data['profileSettings'].get('NO3_RATIO', 8.25))
+        nh4_ratio = 1.0
         
-        # Для миллиграммов применяем целочисленное округление
-        if 'fertilizers' in rounded_response:
-            for fert in rounded_response['fertilizers'].values():
-                if 'миллиграммы' in fert:
-                    fert['миллиграммы'] = int(round(fert['миллиграммы']))
+        calculator.target_profile['N (NO3-)'] = total_n * (no3_ratio / (no3_ratio + nh4_ratio))
+        calculator.target_profile['N (NH4+)'] = total_n * (nh4_ratio / (no3_ratio + nh4_ratio))
         
-        return jsonify(rounded_response)
+        # Выполнение расчета
+        results = calculator.calculate()
+        return jsonify(results)
         
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+
+
+
+
+
+
+
+
+
+
+
+        
+
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))