进水总氮相关优化处理

slibra-quartz/src/main/java/com/slibra/quartz/task/AsyncTask.java

@@ -1963,7 +1963,7 @@ public class AsyncTask {
         if(csCodExecute && !Objects.isNull(cscodBzz) && cscodBzz.compareTo(BigDecimal.ZERO) > 0 && !Objects.isNull(cscodGkz) && cscodGkz.compareTo(BigDecimal.ZERO) > 0)
             handleXinYiWarningsCsOriginCod(cscodBzz, csCod, cscodGkz, CS_COD.getCode(), tXinyiIndustry, normConfig, getCwrwfhzByDetail(jsSlq, tXinyiIndustry.getJsCod(), jsslSjz, normConfig.getJscodSjz()));
         if(jsZDExecute && !Objects.isNull(jszdSjz) && jszdSjz.compareTo(BigDecimal.ZERO) > 0)
-            handleXinYiWarningRecordJSOrigin(jszdSjz, jsTn, BusinessEnum.WarningCategoryEnum.JS_ZD.getCode(), tXinyiIndustry, normConfig, getCwrwfhzByDetail(jsSlq, tXinyiIndustry.getJsTn(), jsslSjz, normConfig.getJszdSjz()));
+            handleXinYiWarningRecordJSOriginZD(jszdSjz, jsTn, BusinessEnum.WarningCategoryEnum.JS_ZD.getCode(), tXinyiIndustry, normConfig, getCwrwfhzByDetail(jsSlq, tXinyiIndustry.getJsTn(), jsslSjz, normConfig.getJszdSjz()));
         if(jsADExecute && !Objects.isNull(jsadSjz) && jsadSjz.compareTo(BigDecimal.ZERO) > 0)
             handleXinYiWarningRecordJSOriginNh3(jsadSjz, jsNh3, BusinessEnum.WarningCategoryEnum.JS_AD.getCode(), tXinyiIndustry, normConfig, getCwrwfhzByDetail(jsSlq, tXinyiIndustry.getJsNh3(), jsslSjz, normConfig.getJsadSjz()));
     }
@@ -4080,6 +4080,50 @@ public class AsyncTask {
 
 
 
+    /**
+     * 不同指标报警规则不一样，全部区分开来处理，此方法为：总氮
+     * 通过输入的值 生成对应类型的报警对象（进水）- 总氮
+     *
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @return
+     */
+    private void handleXinYiWarningRecordJSOriginZD(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz) {
+
+        Date nowDate = DateUtils.getNowDate();
+
+        List<TXinyiIndustry> tXinyiIndustries = this.xinyiIndustryMapper.selectNIndustry(INT_8);
+        if(CollectionUtils.isEmpty(tXinyiIndustries) || tXinyiIndustries.size() < INT_8){
+            log.error("处理生化报警时，获取最近的8条工业库数据失败~~~~~~~");
+            return ;
+        }
+        TXinyiIndustry tXinyiIndustry1 = tXinyiIndustries.get(INDEX_1);//前一个小时
+
+        //拼接决策的最近8小时的值
+        String last8Str = this.getJsNh3StrByList(tXinyiIndustries);
+
+        //单点突变-异常升高报警
+        if (existsJsZDYCSG(jsBzz, currentVal, category, tXinyiIndustry, normConfig, cwrwfhz, tXinyiIndustries, nowDate, last8Str))
+            return;
+
+        //单点突变-异常偏低报警
+        //2025年04月15日15:45:48 这种的暂时先不报
+
+        //2025年04月16日14:35:48 新增高低值设备报警
+        if (existsJsZDGDZ(jsBzz, currentVal, category, tXinyiIndustry, normConfig, cwrwfhz, tXinyiIndustries, nowDate, last8Str))
+            return;
+
+        //最开始的工艺报警  （超标准工艺报警） 2025年04月16日15:40:23 改成只有超标准才会报警，并且具体逻辑做拆分
+        normalIndustryWarningJsTD(jsBzz, currentVal, category, tXinyiIndustry, normConfig, cwrwfhz, nowDate, tXinyiIndustries);
+
+    }
+
+
+
     /**
      * 不同指标报警规则不一样，全部区分开来处理，此方法为：氨氮
      * 通过输入的值 生成对应类型的报警对象（进水）- 氨氮
@@ -4122,6 +4166,75 @@ public class AsyncTask {
 
     }
 
+
+    /**
+     * 最开始的工艺报警  （超标准工艺报警） -- 进水总氮
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param nowDate
+     * @param tXinyiIndustries
+     */
+    private void normalIndustryWarningJsTD(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, Date nowDate, List<TXinyiIndustry> tXinyiIndustries) {
+        //新的判断进水氨氮是否超标
+        TXinyiWarningRecord tXinyiWarningRecord = existsNormalJsZD(jsBzz, currentVal, category, cwrwfhz, tXinyiIndustries, normConfig);
+
+        //最近3条输出 连续升高趋势 和 新增的报警都需要
+        //当前状态正常 需要查询历史有无正在报警的数据，如果有，将报警状态改完2(系统自动关闭)
+        List<TXinyiWarningRecord> tXinyiWarningRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(TXinyiWarningRecord.builder().type(0).category(category).status(0).build());
+        if(Objects.isNull(tXinyiWarningRecord)){//数据正常，无告警信息
+            if(!CollectionUtils.isEmpty(tXinyiWarningRecords)){
+                log.info( "{}:现在恢复正常，历史报警数据为{}", category,JSON.toJSONString(tXinyiWarningRecords));
+                for (TXinyiWarningRecord xinyiWarningRecord : tXinyiWarningRecords) {
+                    closeWarning(xinyiWarningRecord);
+                }
+            }
+        }else{//有告警信息
+            if(CollectionUtils.isEmpty(tXinyiWarningRecords)){//之前没有告警记录
+                //保存到数据库中
+                //2024年7月15日11:06:16 因为只有一个告警记录，但是如果一直报警，现在报警时间取的是更新时间，兼容第一次报警处理
+                tXinyiWarningRecord.setUpdateTime(nowDate);
+                this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(tXinyiWarningRecord);
+                //继续调用决策
+                this.handleDecision(tXinyiWarningRecord, tXinyiIndustry, normConfig, false, nowDate);
+            }else{
+                log.info("{}:之前已经有过告警记录了，且还是继续报警，无需重复添加报警，但是决策仍然要调用", category);
+                for (TXinyiWarningRecord xinyiWarningRecord : tXinyiWarningRecords) {//理论上只有一个的
+                    //2024年7月5日10:45:24 逻辑调整：更新一直报警的那条记录的显示值
+                    xinyiWarningRecord.setWarningVal(tXinyiWarningRecord.getWarningVal());
+//                        xinyiWarningRecord.setDesignVal(tXinyiWarningRecord.getDesignVal());
+//                        tXinyiWarningRecord.setControlVal(tXinyiWarningRecord.getControlVal());
+                    xinyiWarningRecord.setTime(tXinyiWarningRecord.getTime());
+                    xinyiWarningRecord.setUpdateTime(nowDate);
+                    xinyiWarningRecord.setUpdateBy(WARNING_DEFAULT_CREATE);
+                    //2024年7月15日11:07:33 报警的级别也要重新计算并更新
+                    xinyiWarningRecord.setLevel(tXinyiWarningRecord.getLevel());
+                    //2024年7月31日09:20:47 报警的原因（超标还是超管控也需要更新）
+                    xinyiWarningRecord.setReason(tXinyiWarningRecord.getReason());
+                    //更新数据库
+                    this.xinyiWarningRecordMapper.updateTXinyiWarningRecord(xinyiWarningRecord);
+                    //继续调用决策
+                    this.handleDecision(xinyiWarningRecord, tXinyiIndustry, normConfig, false, nowDate);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * 最开始的工艺报警  （超标准工艺报警） -- 进水氨氮
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param nowDate
+     * @param tXinyiIndustries
+     */
     private void normalIndustryWarningJsNh3(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, Date nowDate, List<TXinyiIndustry> tXinyiIndustries) {
         //新的判断进水氨氮是否超标
         TXinyiWarningRecord tXinyiWarningRecord = existsNormalJsNh3(jsBzz, currentVal, category, cwrwfhz, tXinyiIndustries, normConfig);
@@ -4167,8 +4280,68 @@ public class AsyncTask {
         }
     }
 
+
+    /**
+     * 根据新的规则，判断进水氨氮是否超标，超标了则返回报警对象；没有超标，返回空对象 -- 进水总氮
+     *
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param cwrwfhz
+     * @param tXinyiIndustries
+     * @param normConfig
+     * @return
+     */
+    private TXinyiWarningRecord existsNormalJsZD(BigDecimal jsBzz, BigDecimal currentVal, String category, BigDecimal cwrwfhz, List<TXinyiIndustry> tXinyiIndustries, TXinyiNormConfig normConfig) {
+        boolean flag = false;
+        TXinyiIndustry tXinyiIndustry = tXinyiIndustries.get(INDEX_0);
+        BigDecimal jsTn0 = tXinyiIndustry.getJsTn();
+        BigDecimal jsTn1 = tXinyiIndustries.get(INDEX_1).getJsTn();
+        BigDecimal jsTn2 = tXinyiIndustries.get(INDEX_2).getJsTn();
+        BigDecimal jsTn3 = tXinyiIndustries.get(INDEX_3).getJsTn();
+        if(!Objects.isNull(jsTn0) && jsTn0.compareTo(jsBzz) > 0 && !Objects.isNull(jsTn1) && jsTn1.compareTo(jsBzz) > 0
+                && !Objects.isNull(jsTn2) && jsTn2.compareTo(jsBzz) > 0 && !Objects.isNull(jsTn3) && jsTn3.compareTo(jsBzz) > 0)
+            flag = true;//最近4个都超标
+        if(!Objects.isNull(jsTn0) && jsTn0.compareTo(jsBzz) > 0 && !Objects.isNull(jsTn1) && jsTn0.compareTo(jsTn1) >= 0
+                && !Objects.isNull(jsTn2) && jsTn1.compareTo(jsTn2) >= 0)
+            flag = true;//最新的超标了并且连续3个值都有升高趋势
+        BigDecimal jsCod = tXinyiIndustry.getJsCod();
+        BigDecimal jsNh3 = tXinyiIndustry.getJsNh3();
+        BigDecimal jsTp = tXinyiIndustry.getJsTp();
+        if(!Objects.isNull(jsTn0) && jsTn0.compareTo(jsBzz) > 0 && (!Objects.isNull(jsCod) && jsCod.compareTo(BigDecimal.valueOf(630)) > 0
+                || !Objects.isNull(jsNh3) && jsNh3.compareTo(BigDecimal.valueOf(58)) > 0 || !Objects.isNull(jsTp) && jsTp.compareTo(BigDecimal.valueOf(7.1)) > 0))
+            flag = true;
+        if(!flag)
+            return null;
+        //存在符合的报警情况，生成报警对象
+        TXinyiWarningRecord tXinyiWarningRecord = new TXinyiWarningRecord();
+        /*String category = BusinessEnum.WarningCategoryEnum.CS_AD.getCode();*/
+        tXinyiWarningRecord.setStatus(0);
+        tXinyiWarningRecord.setType(0);
+        tXinyiWarningRecord.setCategory(category);
+        tXinyiWarningRecord.setTime(DateUtils.getNowDate());
+        tXinyiWarningRecord.setWarningVal(currentVal);
+        tXinyiWarningRecord.setDesignVal(jsBzz);
+//        tXinyiWarningRecord.setControlVal(csGkz);
+        tXinyiWarningRecord.setCreateBy(WARNING_DEFAULT_CREATE);
+        tXinyiWarningRecord.setCreateTime(DateUtils.getNowDate());
+        tXinyiWarningRecord.setRemark(ZERO_SZ_WARNING.getCode());
+        //2025年02月10日14:45:08 下面是新增加的字段
+        tXinyiWarningRecord.setWaterType(BusinessEnum.WaterTypeEnum.JS.getCode());
+        //超污染物限制：计算公式为：当前氨氮/氨氮设计值 或者 当前氨氮/氨氮管控值（智能工单使用）  这里是出水的 【需要根据超标还是超管控，具体计算】
+        //超污染物负荷值：计算公式为：当前水量与氨氮乘积  /  设计水量与设计进水氨氮的乘积（智能工单使用）
+        tXinyiWarningRecord.setCwrwfhz(cwrwfhz);//2025年02月14日10:48:32 具体的值由上游传过来
+        tXinyiWarningRecord.setReason(category + CHAOBIAO_WARNING);
+        tXinyiWarningRecord.setLevel(WARNING_LEVEL_ONE);
+        tXinyiWarningRecord.setSymbol(BusinessEnum.WarningSymbolEnum.CBZZ.getCode());
+        tXinyiWarningRecord.setCwrwxz(getCwrwxzByDetail(currentVal, normConfig, category, true));//根据当前值和类型以及是否超标处理
+
+        return tXinyiWarningRecord;
+    }
+
+
     /**
-     * 根据新的规则，判断进水氨氮是否超标，超标了则返回报警对象；没有超标，返回空对象
+     * 根据新的规则，判断进水氨氮是否超标，超标了则返回报警对象；没有超标，返回空对象 -- 进水氨氮
      *
      * @param jsBzz
      * @param currentVal
@@ -4225,6 +4398,80 @@ public class AsyncTask {
         return tXinyiWarningRecord;
     }
 
+
+
+    /**
+     * 判断进水总氮是否存在异常升高并处理相关报警
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param tXinyiIndustries
+     * @param nowDate
+     * @param last8Str
+     * @return
+     */
+    private boolean existsJsZDYCSG(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, List<TXinyiIndustry> tXinyiIndustries, Date nowDate, String last8Str) {
+        if(!CollectionUtils.isEmpty(tXinyiIndustries) && tXinyiIndustries.size() == INT_8){
+            //查询同类型的历史报警
+            TXinyiWarningRecord warningRecordYCSG = TXinyiWarningRecord.builder().type(0).category(category).symbol(BusinessEnum.WarningSymbolEnum.SJYC_YCSG.getCode()).status(0).build();
+            List<TXinyiWarningRecord> tXinyiNoChangeYCSGRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(warningRecordYCSG);
+            //2025年02月21日14:33:37 这里要改成当前值和上个小时比较  上个小时和上上个小时比较
+            Map<String, BigDecimal> resultMap = existsYCSGJsZD(currentVal, category, tXinyiIndustries);
+            BigDecimal exceedVal = resultMap.get(EXCEEDVAL);
+            if(!Objects.isNull(exceedVal)){//这里不能只返回一个布尔类型的结果，因为还要获取百分比的值
+                //关闭同类型的其他报警
+                closeOtherWarningsByCategory(category, BusinessEnum.WarningSymbolEnum.SJYC_YCSG.getCode());
+                //触发报警 并且模拟大模型返回决策问答数据
+                if(CollectionUtils.isEmpty(tXinyiNoChangeYCSGRecords)){
+                    //插入该类型报警
+                    warningRecordYCSG.setTime(nowDate);
+                    warningRecordYCSG.setReason(category + BusinessEnum.WarningSymbolEnum.SJYC_YCSG.getMsg());
+                    warningRecordYCSG.setWaterType(BusinessEnum.WaterTypeEnum.JS.getCode());
+                    warningRecordYCSG.setSymbol(BusinessEnum.WarningSymbolEnum.SJYC_YCSG.getCode());
+                    warningRecordYCSG.setCreateBy(WARNING_DEFAULT_CREATE);
+                    warningRecordYCSG.setCreateTime(nowDate);
+                    warningRecordYCSG.setWarningVal(currentVal);
+                    warningRecordYCSG.setDesignVal(jsBzz);
+                    warningRecordYCSG.setRemark(ZERO_SZ_WARNING.getCode());
+                    warningRecordYCSG.setCwrwfhz(cwrwfhz);
+                    warningRecordYCSG.setCwrwxz(getCwrwxzByDetail(currentVal, normConfig, category, true));//根据当前值和类型以及是否超标处理
+                    this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(warningRecordYCSG);
+                    //同时处理决策 不用调用大模型，本地处理问答
+                    addChatRecordByYCSGNew(warningRecordYCSG, tXinyiIndustry, normConfig, category, exceedVal, resultMap.get(LASTVAL), last8Str);
+                }else{
+                    log.info("工业库报警的时候，发现存在异常升高的报警，并且已经有该类型报警了，不做任何处理");
+                    //2025年04月16日15:56:47 这种的继续报警，所以决策还需要再次调用一次
+                    addChatRecordByYCSGNew(warningRecordYCSG, tXinyiIndustry, normConfig, category, exceedVal, resultMap.get(LASTVAL), last8Str);
+                }
+                //后续的报警不再进行
+                log.info("工业库报警的时候，发现存在{}异常升高的报警，后续报警不再处理", category);
+                return true;
+            }else{//不存在 查看历史是否有报警，有的话关闭
+                if(!CollectionUtils.isEmpty(tXinyiNoChangeYCSGRecords)){
+                    closeWarning(tXinyiNoChangeYCSGRecords.get(0));
+                }
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * 判断进水氨氮是否存在异常升高并处理相关报警
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param tXinyiIndustries
+     * @param nowDate
+     * @param last8Str
+     * @return
+     */
     private boolean existsJsNh3YCSG(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, List<TXinyiIndustry> tXinyiIndustries, Date nowDate, String last8Str) {
         if(!CollectionUtils.isEmpty(tXinyiIndustries) && tXinyiIndustries.size() == INT_8){
             //查询同类型的历史报警
@@ -4271,6 +4518,78 @@ public class AsyncTask {
     }
 
 
+    /**
+     * 判断是否存在高低值并处理相关报警-进水总氮
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param tXinyiIndustries
+     * @param nowDate
+     * @param last8Str
+     * @return
+     */
+    private boolean existsJsZDGDZ(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, List<TXinyiIndustry> tXinyiIndustries, Date nowDate, String last8Str) {
+        if(!CollectionUtils.isEmpty(tXinyiIndustries) && tXinyiIndustries.size() == INT_8){
+            //查询同类型的历史报警
+            TXinyiWarningRecord warningRecordGDZ = TXinyiWarningRecord.builder().type(0).category(category).symbol(BusinessEnum.WarningSymbolEnum.SJYC_GDZ.getCode()).status(0).build();
+            List<TXinyiWarningRecord> tXinyiNoChangeGDZRecords = this.xinyiWarningRecordMapper.selectTXinyiWarningRecordList(warningRecordGDZ);
+            //2025年02月21日14:33:37 这里要改成当前值和上个小时比较  上个小时和上上个小时比较
+            Map<String, BigDecimal> resultMap = existsGdzJsZD(currentVal, category, tXinyiIndustries);
+            BigDecimal exceedVal = resultMap.get(EXCEEDVAL);
+            if(!Objects.isNull(exceedVal)){//这里不能只返回一个布尔类型的结果，因为还要获取百分比的值
+                //关闭同类型的其他报警
+                closeOtherWarningsByCategory(category, BusinessEnum.WarningSymbolEnum.SJYC_GDZ.getCode());
+                //触发报警 并且模拟大模型返回决策问答数据
+                if(CollectionUtils.isEmpty(tXinyiNoChangeGDZRecords)){
+                    //插入该类型报警
+                    warningRecordGDZ.setTime(nowDate);
+                    warningRecordGDZ.setReason(category + BusinessEnum.WarningSymbolEnum.SJYC_GDZ.getMsg());
+                    warningRecordGDZ.setWaterType(BusinessEnum.WaterTypeEnum.JS.getCode());
+                    warningRecordGDZ.setSymbol(BusinessEnum.WarningSymbolEnum.SJYC_GDZ.getCode());
+                    warningRecordGDZ.setCreateBy(WARNING_DEFAULT_CREATE);
+                    warningRecordGDZ.setCreateTime(nowDate);
+                    warningRecordGDZ.setWarningVal(currentVal);
+                    warningRecordGDZ.setDesignVal(jsBzz);
+                    warningRecordGDZ.setRemark(ZERO_SZ_WARNING.getCode());
+                    warningRecordGDZ.setCwrwfhz(cwrwfhz);
+                    warningRecordGDZ.setCwrwxz(getCwrwxzByDetail(currentVal, normConfig, category, true));//根据当前值和类型以及是否超标处理
+                    this.xinyiWarningRecordMapper.insertTXinyiWarningRecord(warningRecordGDZ);
+                    //同时处理决策 不用调用大模型，本地处理问答
+                    addChatRecordByGDZ(warningRecordGDZ, tXinyiIndustry, normConfig, category, exceedVal, resultMap.get(LASTVAL), last8Str);
+                }else{
+                    log.info("工业库报警的时候，发现存在高低值的报警，并且已经有该类型报警了，不做任何处理");
+                    //2025年04月16日15:56:47 这种的继续报警，所以决策还需要再次调用一次
+                    addChatRecordByGDZ(warningRecordGDZ, tXinyiIndustry, normConfig, category, exceedVal, resultMap.get(LASTVAL), last8Str);
+                }
+                //后续的报警不再进行
+                log.info("工业库报警的时候，发现存在{}高低值的报警，后续报警不再处理", category);
+                return true;
+            }else{//不存在 查看历史是否有报警，有的话关闭
+                if(!CollectionUtils.isEmpty(tXinyiNoChangeGDZRecords)){
+                    closeWarning(tXinyiNoChangeGDZRecords.get(0));
+                }
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * 判断是否存在高低值并处理相关报警-进水氨氮
+     * @param jsBzz
+     * @param currentVal
+     * @param category
+     * @param tXinyiIndustry
+     * @param normConfig
+     * @param cwrwfhz
+     * @param tXinyiIndustries
+     * @param nowDate
+     * @param last8Str
+     * @return
+     */
     private boolean existsJsNh3GDZ(BigDecimal jsBzz, BigDecimal currentVal, String category, TXinyiIndustry tXinyiIndustry, TXinyiNormConfig normConfig, BigDecimal cwrwfhz, List<TXinyiIndustry> tXinyiIndustries, Date nowDate, String last8Str) {
         if(!CollectionUtils.isEmpty(tXinyiIndustries) && tXinyiIndustries.size() == INT_8){
             //查询同类型的历史报警
@@ -4650,10 +4969,44 @@ public class AsyncTask {
     }
 
 
+    /**
+     *
+     * 2025年04月16日14:20:11 异常升高逻辑也不同指标不同的判断方式
+     * 进水总氮异常升高的具体判断逻辑
+     * 【工业库异常升高】先判断该指标是否超过最大值，如果超过了，返回对应的超过的值； 如果没有超标，返回null。
+     * 一个字段返回用作2个地方
+     * 2025年03月06日10:35:30 判断是否超标，不再获取最近3个小时；最近2个小时比较即可。
+     * 2025年03月19日10:47:18 返回逻辑调整：额外再返回一个上个小时同指标的值，决策力需要展示该值。
+     * @param currentVal
+     * @param category
+     * @param industryList
+     * @return
+     */
+    private Map<String, BigDecimal> existsYCSGJsZD(BigDecimal currentVal, String category, List<TXinyiIndustry> industryList) {
+
+        Map<String, BigDecimal> resultMap = new HashMap<>();
+        TXinyiIndustry tXinyiIndustry1 = industryList.get(INDEX_1);
+//        BigDecimal compareVal = BigDecimal.valueOf(YCSG_VAL_CONF);
+        BigDecimal compareVal = BigDecimal.valueOf(0.7D);
+        BigDecimal jsTn1 = tXinyiIndustry1.getJsTn();
+        TXinyiIndustry tXinyiIndustryCurrent = industryList.get(INDEX_0);
+        BigDecimal jsNh3 = tXinyiIndustryCurrent.getJsNh3();
+        if(!Objects.isNull(currentVal) && !Objects.isNull(jsTn1)){
+            BigDecimal divide1 = currentVal.subtract(jsTn1).divide(jsTn1, NUMBER_SCALE_4, RoundingMode.HALF_UP);
+            //2025年04月16日14:28:55 触发条件修改： 触发条件：（现在-前一小时）/前一小时*100%> 70%  and  进水总氮 > 65 and 进水氨氮<58
+            if(divide1.compareTo(compareVal) > 0  && currentVal.compareTo(BigDecimal.valueOf(65)) > 0 && jsNh3.compareTo(BigDecimal.valueOf(58)) < 0){
+                resultMap.put(EXCEEDVAL, divide1);
+                resultMap.put(LASTVAL, jsTn1);
+            }
+        }
+        return resultMap;
+    }
+
 
     /**
      *
      * 2025年04月16日14:20:11 异常升高逻辑也不同指标不同的判断方式
+     * 进水氨氮异常升高的具体判断逻辑
      * 【工业库异常升高】先判断该指标是否超过最大值，如果超过了，返回对应的超过的值； 如果没有超标，返回null。
      * 一个字段返回用作2个地方
      * 2025年03月06日10:35:30 判断是否超标，不再获取最近3个小时；最近2个小时比较即可。
@@ -4684,6 +5037,25 @@ public class AsyncTask {
     }
 
 
+    /**
+     * 进水总氮是否存在高低值切换
+     * @param currentVal
+     * @param category
+     * @param industryList
+     * @return
+     */
+    private Map<String, BigDecimal> existsGdzJsZD(BigDecimal currentVal, String category, List<TXinyiIndustry> industryList) {
+
+        Map<String, BigDecimal> resultMap = new HashMap<>();
+        BigDecimal compareValHigh = BigDecimal.valueOf(65);
+        BigDecimal compareValLow = BigDecimal.valueOf(16);
+
+        if(gdzJsZD(compareValHigh, compareValLow, industryList))
+            resultMap.put(EXCEEDVAL, compareValHigh);//这里随便存一个值就可以 有值代表存在高低值  没有就是不存在
+        return resultMap;
+    }
+
+
     /**
      * 进水氨氮是否存在高低值切换
      * @param currentVal
@@ -4702,25 +5074,48 @@ public class AsyncTask {
         return resultMap;
     }
 
+
+    /**
+     * 判断进水总氮的8个值 是否存在高低值切换报警
+     * @param compareValHigh
+     * @param compareValLow
+     * @param industryList
+     * @return
+     */
+    private boolean gdzJsZD(BigDecimal compareValHigh, BigDecimal compareValLow, List<TXinyiIndustry> industryList) {
+        BigDecimal val0 = industryList.get(INDEX_0).getJsTn();
+        BigDecimal val1 = industryList.get(INDEX_1).getJsTn();
+        BigDecimal val2 = industryList.get(INDEX_2).getJsTn();
+        BigDecimal val3 = industryList.get(INDEX_3).getJsTn();
+        BigDecimal val4 = industryList.get(INDEX_4).getJsTn();
+        BigDecimal val5 = industryList.get(INDEX_5).getJsTn();
+        BigDecimal val6 = industryList.get(INDEX_6).getJsTn();
+        BigDecimal val7 = industryList.get(INDEX_7).getJsTn();
+
+        //判断规则：
+        return commonGdzCompare(compareValHigh, compareValLow, val0, val1, val2, val3, val4, val5, val6, val7);
+    }
+
+
     /**
-     * 判断8个值 是否存在高低值切换报警
+     * 判断进水氨氮的8个值 是否存在高低值切换报警
      * @param compareValHigh
      * @param compareValLow
      * @param industryList
      * @return
      */
     private boolean gdzJsNh3(BigDecimal compareValHigh, BigDecimal compareValLow, List<TXinyiIndustry> industryList) {
-        BigDecimal jsNh30 = industryList.get(INDEX_0).getJsNh3();
-        BigDecimal jsNh31 = industryList.get(INDEX_1).getJsNh3();
-        BigDecimal jsNh32 = industryList.get(INDEX_2).getJsNh3();
-        BigDecimal jsNh33 = industryList.get(INDEX_3).getJsNh3();
-        BigDecimal jsNh34 = industryList.get(INDEX_4).getJsNh3();
-        BigDecimal jsNh35 = industryList.get(INDEX_5).getJsNh3();
-        BigDecimal jsNh36 = industryList.get(INDEX_6).getJsNh3();
-        BigDecimal jsNh37 = industryList.get(INDEX_7).getJsNh3();
+        BigDecimal val0 = industryList.get(INDEX_0).getJsNh3();
+        BigDecimal val1 = industryList.get(INDEX_1).getJsNh3();
+        BigDecimal val2 = industryList.get(INDEX_2).getJsNh3();
+        BigDecimal val3 = industryList.get(INDEX_3).getJsNh3();
+        BigDecimal val4 = industryList.get(INDEX_4).getJsNh3();
+        BigDecimal val5 = industryList.get(INDEX_5).getJsNh3();
+        BigDecimal val6 = industryList.get(INDEX_6).getJsNh3();
+        BigDecimal val7 = industryList.get(INDEX_7).getJsNh3();
 
         //判断规则：
-        return commonGdzCompare(compareValHigh, compareValLow, jsNh30, jsNh31, jsNh32, jsNh33, jsNh34, jsNh35, jsNh36, jsNh37);
+        return commonGdzCompare(compareValHigh, compareValLow, val0, val1, val2, val3, val4, val5, val6, val7);
     }
 
     private boolean commonGdzCompare(BigDecimal compareValHigh, BigDecimal compareValLow, BigDecimal jsNh30, BigDecimal jsNh31, BigDecimal jsNh32, BigDecimal jsNh33, BigDecimal jsNh34, BigDecimal jsNh35, BigDecimal jsNh36, BigDecimal jsNh37) {
@@ -5302,7 +5697,8 @@ public class AsyncTask {
             BigDecimal jsTn1 = tXinyiIndustry1.getJsTn();
             BigDecimal jsTn2 = tXinyiIndustry2.getJsTn();
             BigDecimal jsTn3 = tXinyiIndustry3.getJsTn();
-            if(!Objects.isNull(currentVal) && !Objects.isNull(jsTn1) && currentVal.compareTo(jsTn1) == 0
+            //2025年04月18日13:55:19 新增新的判断规则 连续4小时，进水氨氮数值不变 and 进水总氮 > 65
+            if(!Objects.isNull(currentVal) && currentVal.compareTo(BigDecimal.valueOf(65)) > 0 && !Objects.isNull(jsTn1) && currentVal.compareTo(jsTn1) == 0
                     && !Objects.isNull(jsTn2) && currentVal.compareTo(jsTn2) == 0 && !Objects.isNull(jsTn3) && currentVal.compareTo(jsTn3) == 0)
                 result = true;
         }else if(BusinessEnum.WarningCategoryEnum.JS_ZL.getCode().equals(category)){
@@ -5316,7 +5712,8 @@ public class AsyncTask {
             BigDecimal jsNh31 = tXinyiIndustry1.getJsNh3();
             BigDecimal jsNh32 = tXinyiIndustry2.getJsNh3();
             BigDecimal jsNh33 = tXinyiIndustry3.getJsNh3();
-            if(!Objects.isNull(currentVal) && !Objects.isNull(jsNh31) && currentVal.compareTo(jsNh31) == 0
+            //2025年04月18日13:55:19 新增新的判断规则 连续4小时，进水氨氮数值不变 and 当前进水氨氮 > 58
+            if(!Objects.isNull(currentVal) && currentVal.compareTo(BigDecimal.valueOf(58)) > 0 && !Objects.isNull(jsNh31) && currentVal.compareTo(jsNh31) == 0
                     && !Objects.isNull(jsNh32) && currentVal.compareTo(jsNh32) == 0 && !Objects.isNull(jsNh33) && currentVal.compareTo(jsNh33) == 0)
                 result = true;
         }else{