sis-background/power-fitting-JN/src/main/java/com.gyee.power.fitting/dispersionanalysis/InverterPowerAnalysis2.java

package com.gyee.power.fitting.dispersionanalysis;

import com.alibaba.fastjson.JSONObject;
import com.gyee.power.fitting.common.alg.PolynomialCurveFitting;
import com.gyee.power.fitting.common.result.JsonResult;
import com.gyee.power.fitting.common.result.ResultCode;
import com.gyee.power.fitting.model.custom.PhotovoltaicInfo;
import com.gyee.power.fitting.service.impl.IvPvCurveFittingService;
import org.apache.commons.math3.fitting.WeightedObservedPoints;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

//逆变器单位装机输出功率离散率分析
//@CrossOrigin
//@RequestMapping("/discreteness")
//@RestController
@Component
public class InverterPowerAnalysis2 {

    @Resource
    private IvPvCurveFittingService curveFittingService;
    @Resource
    private PolynomialCurveFitting pncf;

    // 计算平均功率
    public double calculateAveragePower(List<Double> powerData) {
        double sum = 0.0;
        for (Double power : powerData) {
            sum += power;
        }
        return sum / powerData.size();
    }

    // 根据复杂规则分析逆变器状态
    public String analyzeInverterStatus(double powerDeviation, double averagePower) {
        if (powerDeviation < 0.1 && averagePower > 800) {
            return "运行稳定";
        } else if (powerDeviation < 0.2 && averagePower > 600) {
            return "运行良好";
        } else if (powerDeviation < 0.3 && averagePower > 400) {
            return "运行水平有待提高";
        } else {
            return "必须整改";
        }
    }

    @GetMapping("/rate")
    private JSONObject getFileList(
            @RequestParam(value = "station", required = true) String station,
            @RequestParam(value = "inverters", required = false) List<String> inverters,
            @RequestParam(value = "startdate", required = true) long startdate,
            @RequestParam(value = "interval", required = false) Integer interval,
            @RequestParam(value = "enddate", required = true) long enddate) {

        Map<String, List<PhotovoltaicInfo>> datasInfos = curveFittingService.getDatas2File1(station, startdate, enddate, interval);

        /*List<PhotovoltaicInfo> infos = new ArrayList<>();
        //单台拟合
        if (inverters.size() == 1) {
            infos = datasInfos.get(inverters.get(0));
        //多台拟合
        } else if (inverters.size() > 1) {
            infos = inverters.stream().flatMap(inverter -> datasInfos.get(inverter).stream()).collect(Collectors.toList());
        //全场拟合
        } else {
            infos = datasInfos.values().stream().flatMap(List::stream).collect(Collectors.toList());
        }*/

        List<InverterData2> inverterData2s = new ArrayList<>();
        datasInfos.forEach((k, v) -> {

            WeightedObservedPoints points = new WeightedObservedPoints();
            for (PhotovoltaicInfo info : v) {
                if (info.getS() < 1) {
                    points.add(0, 0);
                }
                points.add(info.getS(), info.getActualP());
            }

            double[] run = pncf.run(points);

            inverterData2s.add(analyzeInverterPerformance(v, run, k));
        });

        return JsonResult.successData(ResultCode.SUCCESS, inverterData2s);
    }

    // 分析逆变器性能，包括计算离散率和平均功率
    public InverterData2 analyzeInverterPerformance(List<PhotovoltaicInfo> infos, double[] run, String inverterId) {

        List<Double> collect = infos.stream().map(info -> info.getS()).collect(Collectors.toList());
        // 计算功率离散率
        double powerDeviation = calculatePowerDeviation(collect, run);
        // 计算平均功率
        double averagePower = calculateAveragePower(collect);
        // 分析逆变器状态
        String inverterStatus = analyzeInverterStatus(powerDeviation, averagePower);

        return new InverterData2(inverterId, powerDeviation, averagePower, inverterStatus, "离散率");
    }

    // 计算功率离散率
    private double calculatePowerDeviation(List<Double> powerData, double[] run) {
        double sum = 0.0;

        // 计算标准差
        for (Double power : powerData) {
            sum += Math.pow(power - pncf.calcPoly(power, run), 2);
        }
        return Math.sqrt(sum / powerData.size());
    }

    // 计算功率离散率
    public double calcPowerDeviation(List<PhotovoltaicInfo> infos, double averagePower) {
        WeightedObservedPoints points = new WeightedObservedPoints();
        for (PhotovoltaicInfo info : infos) {
            if (info.getS() < 1) {
                points.add(0, 0);
            }
            points.add(info.getS(), info.getActualP());
        }

        double[] run = pncf.run(points);

        double sum = 0.0, power;
        // 计算标准差
        for (PhotovoltaicInfo info : infos) {
            power = info.getActualP();
            sum += Math.pow(power - pncf.calcPoly(power, run), 2);
        }
        return Math.sqrt(sum / infos.size());
    }
}