Update app.py

app.py

@@ -790,165 +790,134 @@ NUTRIENT_CONTENT_IN_FERTILIZERS = {
 }
 
 class NutrientCalculator:
-    def __init__(self, volume_liters=1.0):
+    def __init__(self, volume_liters: float = 1.0):
         self.volume = volume_liters
         self.results = {}
-        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
-
-        # Расчёт азота
-        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.target_profile = {
+            'P': 31.0, 'K': 210.0, 'Mg': 24.0,
+            'Ca': 84.0, 'S': 56.439,
+            'N (NO3-)': 0.0, 'N (NH4+)': 0.0
         }
-
-    def _label(self, element):
-        """Форматирование названий элементов для вывода"""
-        labels = {
-            'N (NO3-)': 'NO3',
-            'N (NH4+)': 'NH4'
+        self.actual_profile = {k: 0.0 for k in self.target_profile}
+        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'}
         }
-        return labels.get(element, element)
 
-    def calculate(self):
+    def _apply_fertilizer(self, fert_name: str, element: str, ppm: float):
+        """Основной метод внесения удобрений"""
         try:
-            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+)'])
-            
-            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._apply_k_sulfate()
-            
-            k_deficit = self.target_profile['K'] - self.actual_profile['K']
-            if k_deficit > 0.1:
-                self._apply("Калий азотнокислый", "K", k_deficit)
-            
-            return self.results
-        except Exception as e:
-            print(f"Ошибка при расчёте: {str(e)}")
-            raise
+            if ppm <= 0:
+                return
 
-    def _apply(self, fert_name, main_element, required_ppm):
-        if required_ppm <= 0:
-            return
-            
-        try:
-            content = self.fertilizers[fert_name][main_element]
-            grams = (required_ppm * self.volume) / (content * 1000)
+            content = self.fertilizers[fert_name][element]
+            grams = (ppm * self.volume) / (content * 1000)
             
             if fert_name not in self.results:
-                result = {
-                    'граммы': 0.0,
-                    'миллиграммы': 0,
-                    'вклад в EC': 0.0
+                self.results[fert_name] = {
+                    'grams': 0.0,
+                    'ppm_added': {}
                 }
-                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)
+
+            self.results[fert_name]['grams'] += grams
             
-            fert_ec = 0.0
-            for element, percent in self.fertilizers[fert_name].items():
+            # Обновляем все элементы из удобрения
+            for el, 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
+                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
+
         except KeyError as e:
-            print(f"Ошибка: отсутствует элемент {str(e)} в удобрении {fert_name}")
-            raise
+            raise ValueError(f"Неверный элемент или удобрение: {str(e)}")
 
-    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']
+    def _compensate_with_weights(self, element: str, needed_ppm: float):
+        """Компенсация с учётом весов"""
+        candidates = []
         
-        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)
+        # Ищем все удобрения, которые содержат нужный элемент
+        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
                 
-                k_content = self.fertilizers[fert]["K"]
-                k_from_s = (grams_s * k_content * 1000) / self.volume
+                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
                 
-                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
-
-    def calculate_ec(self):
-        return round(self.total_ec, 2)
+            # Рассчитываем сколько можем внести этим удобрением
+            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 print_report(self):
+    def calculate(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("  Все элементы покрыты полностью")
+            # 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)
+            
+            # 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)
+            
+            # 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._compensate_with_weights("K", k_needed)
+            
+            return self._prepare_results()
+            
         except Exception as e:
-            print(f"Ошибка при выводе отчёта: {str(e)}")
-            raise
-
+            raise RuntimeError(f"Ошибка расчёта: {str(e)}")
+
+    def _prepare_results(self):
+        """Форматируем результаты для ответа"""
+        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
+            }
+        }
 if __name__ == "__main__":
     try:
         calculator = NutrientCalculator(volume_liters=VOLUME_LITERS)