2025.12.18 1. 动态溯源相关分析逻辑调整； 2. 走航报告接口参数调整；

feiyu02

23 小时以前 8eb584869b4fd4de0f51c93f2616f12e51df9193

 src/main/kotlin/com/flightfeather/uav/biz/sourcetrace/model/PollutedSource.kt

@@ -12,7 +12,6 @@
import com.flightfeather.uav.socket.eunm.FactorType
import org.springframework.beans.BeanUtils
import org.springframework.web.context.ContextLoader
import kotlin.math.round

/**
 * 污染来源
@@ -76,14 +75,12 @@

            // 5. 根据污染因子的量级，计算主要的污染场景类型，筛选结果
            val mainSceneType = calSceneType(pollutedData)
            if (mainSceneType != null) {
                result = result.filter {
                    val r = mainSceneType.second.find { s ->
                        s.value == it.typeId.toInt()
                    }
                    r != null
                }.toMutableList()
            }
            result = result.filter {
                val r = mainSceneType.find { s ->
                    s.value == it.typeId.toInt()
                }
                r != null
            }.toMutableList()
            this.sceneList = findClosestStation(sceneInfoRep, result)
        }

@@ -95,8 +92,7 @@
     * 计算可能的相关污染场景类型以及推理结论
     */
    @Throws(Exception::class)
    private fun calSceneType(pollutedData: PollutedData): Pair<String, List<SceneType>>? {
        var des: String? = null
    private fun calSceneType(pollutedData: PollutedData): List<SceneType> {
        val sceneTypes = mutableListOf<SceneType>()
        pollutedData.statisticMap.entries.forEach { s ->
            val res = when (s.key) {
@@ -104,85 +100,35 @@
                FactorType.NO,
                FactorType.NO2,
                    -> {
//                    val coAvg = round(pollutedData.dataList.map { it.co!! }.average()) / 1000
                    val coAvg = round(pollutedData.statisticMap[FactorType.CO]?.avg ?: .0) / 1000
                    "氮氧化合物偏高，CO的量级为${coAvg}mg/m³，一般由于机动车尾气造成，污染源以汽修、加油站为主" to
                            listOf(SceneType.TYPE1, SceneType.TYPE6, SceneType.TYPE10, SceneType.TYPE17)
                    listOf(SceneType.TYPE1, SceneType.TYPE6, SceneType.TYPE10, SceneType.TYPE17)
                }

                FactorType.CO -> "" to listOf(SceneType.TYPE6, SceneType.TYPE10, SceneType.TYPE17)

                FactorType.CO -> listOf(SceneType.TYPE6, SceneType.TYPE10, SceneType.TYPE17)
                FactorType.H2S -> null

                FactorType.SO2 -> null

                FactorType.O3 -> null
                // a) pm2.5、pm10特别高，两者在各情况下同步展示，pm2.5占pm10的比重变化，比重越高，越有可能是餐饮
                // b) pm10特别高、pm2.5较高，大颗粒扬尘污染，只展示pm10，pm2.5占pm10的比重变化，工地为主
                FactorType.PM25,
                FactorType.PM10,
                    -> {
//                    val pm25Avg = round(pollutedData.dataList.map { it.pm25!! }.average() * 10) / 10
//                    val pm10Avg = round(pollutedData.dataList.map { it.pm10!! }.average() * 10) / 10
                    val pm25Avg = round((pollutedData.statisticMap[FactorType.PM25]?.avg ?: .0) * 10) / 10
                    val pm10Avg = round((pollutedData.statisticMap[FactorType.PM10]?.avg ?: .0) * 10) / 10
                    // 计算异常数据的pm2.5占pm10比重的均值
                    val percentageAvg = pollutedData.dataList.map {
                        it.pm25!! / it.pm10!!
                    }.average()
                    val str =
                        "PM2.5量级为${pm25Avg}μg/m³，PM10量级为${pm10Avg}μg/m³，PM2.5占PM10的比重为${round(percentageAvg * 100)}%"
                    if (percentageAvg > 0.666) {
                        "${str}，比重较大，污染源以餐饮为主，工地次之" to
                                listOf(
                                    SceneType.TYPE1,
                                    SceneType.TYPE2,
                                    SceneType.TYPE3,
                                    SceneType.TYPE14,
                                    SceneType.TYPE5,
                                    SceneType.TYPE18
                                )
                    } else if (percentageAvg < 0.333) {
                        "${str}，比重较小，属于大颗粒扬尘污染，污染源以工地为主" to
                                listOf(
                                    SceneType.TYPE1,
                                    SceneType.TYPE2,
                                    SceneType.TYPE3,
                                    SceneType.TYPE14,
                                    SceneType.TYPE5,
                                    SceneType.TYPE18
                                )
                    } else {
                        "${str}，污染源以餐饮、工地为主" to
                                listOf(
                                    SceneType.TYPE1,
                                    SceneType.TYPE2,
                                    SceneType.TYPE3,
                                    SceneType.TYPE14,
                                    SceneType.TYPE5,
                                    SceneType.TYPE18
                                )
                    }
                    listOf(
                        SceneType.TYPE1,
                        SceneType.TYPE2,
                        SceneType.TYPE3,
                        SceneType.TYPE14,
                        SceneType.TYPE5,
                        SceneType.TYPE18
                    )
                }
                // c) VOC较高，同比计算pm2.5的量级，可能存在同步偏高（汽修、加油站）, 同步计算O3是否有高值
                // d) VOC较高，处于加油站（车辆拥堵情况），CO一般较高, 同步计算O3是否有高值

                FactorType.VOC -> {
//                    val pm25Avg = round(pollutedData.dataList.map { it.pm25!! }.average() * 10) / 10
//                    val coAvg = round(pollutedData.dataList.map { it.co!! }.average()) / 1000
//                    val o3Avg = round(pollutedData.dataList.map { it.o3!! }.average() * 10) / 10
                    val pm25Avg = round((pollutedData.statisticMap[FactorType.PM25]?.avg ?: .0)) / 10
                    val coAvg = round((pollutedData.statisticMap[FactorType.CO]?.avg ?: .0)) / 1000
                    val o3Avg = round((pollutedData.statisticMap[FactorType.O3]?.avg ?: .0)) / 10
                    "VOC偏高，同时PM2.5量级为${pm25Avg}μg/m³，CO量级为${coAvg}mg/m³，O3量级为${o3Avg}μg/m³，污染源以汽修、加油站为主" to
                            listOf(SceneType.TYPE5, SceneType.TYPE6, SceneType.TYPE17, SceneType.TYPE12, SceneType.TYPE18)
                    listOf(SceneType.TYPE5, SceneType.TYPE6, SceneType.TYPE17, SceneType.TYPE12, SceneType.TYPE18)
                }

                else -> null
            }
            des = res?.first
            res?.second?.let { sceneTypes.addAll(it) }
            res?.let { sceneTypes.addAll(it) }
        }
        return (des ?: "") to sceneTypes
        return sceneTypes.distinct()
    }

    /**
@@ -233,56 +179,32 @@
        val et = DateUtil.instance.getTime(pollutedData.endTime)

        // 1. 描述异常发生的时间和异常类型
        var txt = "在${st}至${et}之间，出现${pollutedData.exception}"
        var txt = "在${st}至${et}之间，出现${pollutedData.exception}${pollutedData.times}次"

        // 2. 描述异常数据的变化情况
        // 异常数据长度应该大于1，首个值是异常开始数据的前一个正常值,后续为异常数据值（但不一定时间连续）
        if (pollutedData.dataList.size > 1) {
            val historyDataList = pollutedData.historyDataList.map { it.toBaseRealTimeData(BaseRealTimeData::class.java) }
            when (pollutedData.exceptionType) {
                // 量级突变
                ExceptionType.TYPE4.value -> {
                    val exceptionPair = mutableListOf<Pair<BaseRealTimeData, BaseRealTimeData>>()
                    pollutedData.dataList.forEachIndexed { index, baseRealTimeData ->
                        if (index == 0) return@forEachIndexed
                        val preIndex = historyDataList.indexOfFirst {
                            it.dataTime == baseRealTimeData.dataTime
                        }
                        exceptionPair.add(
                            (if (preIndex - 1 < 0) historyDataList[0] else historyDataList[preIndex - 1])
                                    to baseRealTimeData
                        )
        val statArr = mutableListOf<String>()
        pollutedData.statisticMap.entries.forEach { s ->
            val txtArr = mutableListOf<String>()
            s.value.excGroup?.forEach exception@{ p ->
                val preValue = p.getFirstDataValue()
                val curValue = p.getLastDataValue()
                val per = p.per?.times(100)
                val rate = p.rate
                if (preValue == null || curValue == null || per == null) return@exception
                when (pollutedData.exceptionType) {
                    // 量级突变
                    ExceptionType.TYPE4.value -> {
                        txtArr.add("从${preValue}μg/m³突变至${curValue}μg/m³，变化率为${per}%")
                    }
                    val statArr = mutableListOf<String>()
                    pollutedData.statisticMap.entries.forEach { s ->
                        val txtArr = mutableListOf<String>()
                        exceptionPair.forEach exception@{ p ->
                            val preValue = p.first.getByFactorType(s.key)
                            val curValue = p.second.getByFactorType(s.key)
                            if (preValue == null || curValue == null) return@exception
                            val r = round((curValue - preValue) / preValue * 100)
                            txtArr.add("从${preValue}μg/m³突变至${curValue}μg/m³，变化率为${r}%")
                        }
                        statArr.add("${s.key.getTxt()}量级${txtArr.joinToString("，")}")
                    }
                    txt += "，${statArr.joinToString("；")}"
                }
                // 快速上升
                ExceptionType.TYPE9.value -> {
                    pollutedData.statisticMap.entries.forEach { s ->
                        val preValue = pollutedData.dataList.first().getByFactorType(s.key)
                        val curValue = pollutedData.dataList.last().getByFactorType(s.key)
                        if (preValue == null || curValue == null) return@forEach
                        val r = round((curValue - preValue) / preValue * 100)
                        txt += "，${s.key.getTxt()}从${preValue}μg/m³快速上升至${curValue}μg/m³，变化率为${r}%"
                    // 快速上升
                    ExceptionType.TYPE9.value -> {
                        txtArr.add("从${preValue}μg/m³快速上升至${curValue}μg/m³，变化速率为${rate}μg/m³/秒，变化率为${per}%")
                    }
                }
            }
        } else {
            pollutedData.statisticMap.entries.forEach { s ->
                txt += "，${s.key.des}最低值为${s.value.min}μg/m³，最高值为${s.value.max}μg/m³，均值为${s.value.avg}μg/m³"
            }
            statArr.add("${s.key.getTxt()}量级${txtArr.joinToString("，")}")
        }
        txt += "，${statArr.joinToString("；")}"

        // 3. 描述发现的风险源情况
        if (sceneList.isEmpty()) {