package com.gyee.generation.service;//package com.gyee.generation.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.gyee.common.contant.ContantXk;
import com.gyee.common.model.PointData;
import com.gyee.generation.init.CacheContext;
import com.gyee.generation.model.auto.ProBasicEquipment;
import com.gyee.generation.model.auto.ProBasicEquipmentPoint;
import com.gyee.generation.model.auto.ProEconWtwindDayInfo;
import com.gyee.generation.model.vo.WpType;
import com.gyee.generation.service.auto.IProEconWtwindDayInfoService;
import com.gyee.generation.util.DateUtils;
import com.gyee.generation.util.realtimesource.IEdosUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class WtwindDayInfoService {

    //    private static final Logger logger = LoggerFactory.getLogger(WindPowerInfo1Service.class);
    @Resource
    private IEdosUtil edosUtil;

    @Resource
    private IProEconWtwindDayInfoService proEconWtwindDayInfoService;


    /**
     * 计算场站风资源信息
     */
    public void calWtwindDayInfo(Date recordDate) throws Exception {


        Calendar c = Calendar.getInstance();
        c.setTime(recordDate);

        Date end = c.getTime();

        Date begin = DateUtils.truncate(c.getTime());
        //        //判断是否有重复记录，先删除重复记录
        //        QueryWrapper<ProEconWtwindDayInfo> queryWrapper = new QueryWrapper<>();
        //        queryWrapper.eq("record_date",DateUtils.truncate(recordDate));
        //        List<Long> idls = proEconWtwindDayInfoService.list(queryWrapper).stream()
        ////                .filter(i -> i.getRecordDate().compareTo(DateUtils.truncate(recordDate)) == 0)
        //                .map(ProEconWtwindDayInfo::getId)
        //                .collect(Collectors.toList());
        //
        //        if (idls.size() > 0) {
        //
        //            proEconWtwindDayInfoService.removeByIds(idls);
        //
        //        }


        List<ProEconWtwindDayInfo> dayls = new ArrayList<>();
        for (ProBasicEquipment wt : CacheContext.wtls) {
            if (CacheContext.wtpAimap.containsKey(wt.getId()) && wt.getWindpowerstationId().contains(WpType.FDC.id)) {

                Map<String, ProBasicEquipmentPoint> pointmap = CacheContext.wtpAimap.get(wt.getId());
                ProEconWtwindDayInfo pewp = new ProEconWtwindDayInfo();
                initial(pewp);
                pewp.setRecordDate(DateUtils.truncate(recordDate));
                pewp.setWindturbineId(wt.getId());


                //昨日的统计结果
                List<ProEconWtwindDayInfo> pepid1ls = new ArrayList<>();
                Calendar cl = Calendar.getInstance();
                cl.setTime(recordDate);
                //昨日的统计结果
                cl.add(Calendar.DAY_OF_MONTH, -1);
                if (cl.get(Calendar.DAY_OF_MONTH) != 1) {
                    QueryWrapper<ProEconWtwindDayInfo> queryWrapper2 = new QueryWrapper<>();
                    queryWrapper2.eq("record_date", DateUtils.truncate(cl.getTime())).eq("windTurbine_Id", wt.getId());
                    pepid1ls = proEconWtwindDayInfoService.list(queryWrapper2);
                    //                            .stream()
                    //                            .filter(i -> i.getRecordDate().compareTo(DateUtils.truncate(cl.getTime())) == 0
                    //                                    && i.getWindturbineId().equals(wt.getId())
                    //                            )
                    //                            .collect(Collectors.toList());
                }

                //*******************************************年信息统计*********************************************************/
                extracted(recordDate, end, begin, pointmap, pewp, pepid1ls, wt);
                dayls.add(pewp);
                // proEconWtwindDayInfoService.save(pewp);


            }


        }

        //判断是否有重复记录，先删除重复记录
        QueryWrapper<ProEconWtwindDayInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("record_date", DateUtils.truncate(recordDate));
        List<Long> idls = proEconWtwindDayInfoService.list(queryWrapper).stream()
                //                .filter(i -> i.getRecordDate().compareTo(DateUtils.truncate(recordDate)) == 0)
                .map(ProEconWtwindDayInfo::getId)
                .collect(Collectors.toList());

        if (idls.size() > 0) {

            proEconWtwindDayInfoService.removeByIds(idls);

        }
        List<ProEconWtwindDayInfo> templs = new ArrayList<>();
        for (ProEconWtwindDayInfo vo : dayls) {
            templs.add(vo);
            if (templs.size() == 1000) {
                proEconWtwindDayInfoService.saveOrUpdateBatch(templs);
                templs = new ArrayList<>();
            }
        }

        if (!templs.isEmpty()) {
            proEconWtwindDayInfoService.saveOrUpdateBatch(templs);
        }
        //        proEconWtwindDayInfoService.saveBatch(dayls);
    }


    private void extracted(Date recordDate, Date end, Date begin, Map<String, ProBasicEquipmentPoint> pointmap, ProEconWtwindDayInfo pewp, List<ProEconWtwindDayInfo> pepid1ls, ProBasicEquipment wt) throws Exception {
        //*******************************************日信息统计*********************************************************/


        //东
        List<Double> e_fxls = new ArrayList<>();
        List<Double> e_fsls = new ArrayList<>();
        //东东南
        List<Double> ees_fxls = new ArrayList<>();
        List<Double> ees_fsls = new ArrayList<>();
        //东南
        List<Double> es_fxls = new ArrayList<>();
        List<Double> es_fsls = new ArrayList<>();

        //南东南
        List<Double> ses_fxls = new ArrayList<>();
        List<Double> ses_fsls = new ArrayList<>();
        //南
        List<Double> s_fxls = new ArrayList<>();
        List<Double> s_fsls = new ArrayList<>();
        //南西南
        List<Double> sws_fxls = new ArrayList<>();
        List<Double> sws_fsls = new ArrayList<>();

        //西南
        List<Double> ws_fxls = new ArrayList<>();
        List<Double> ws_fsls = new ArrayList<>();

        //西西南
        List<Double> wws_fxls = new ArrayList<>();
        List<Double> wws_fsls = new ArrayList<>();
        //西
        List<Double> w_fxls = new ArrayList<>();
        List<Double> w_fsls = new ArrayList<>();
        //西西北
        List<Double> wwn_fxls = new ArrayList<>();
        List<Double> wwn_fsls = new ArrayList<>();

        //西北
        List<Double> wn_fxls = new ArrayList<>();
        List<Double> wn_fsls = new ArrayList<>();
        //北西北
        List<Double> nwn_fxls = new ArrayList<>();
        List<Double> nwn_fsls = new ArrayList<>();
        //北西北
        List<Double> n_fxls = new ArrayList<>();
        List<Double> n_fsls = new ArrayList<>();
        //北东北
        List<Double> nen_fxls = new ArrayList<>();
        List<Double> nen_fsls = new ArrayList<>();
        //东北
        List<Double> en_fxls = new ArrayList<>();
        List<Double> en_fsls = new ArrayList<>();
        //东东北
        List<Double> een_fxls = new ArrayList<>();
        List<Double> een_fsls = new ArrayList<>();

        double dayjfcs = 0.0;
        double dayfcs = 0.0;

        double zfxcs = 0.0;

        double n_dayjfcs = 0.0;
        double n_dayfcs = 0.0;

        double nen_dayjfcs = 0.0;
        double nen_dayfcs = 0.0;

        double en_dayjfcs = 0.0;
        double en_dayfcs = 0.0;

        double een_dayjfcs = 0.0;
        double een_dayfcs = 0.0;

        double e_dayjfcs = 0.0;
        double e_dayfcs = 0.0;

        double ees_dayjfcs = 0.0;
        double ees_dayfcs = 0.0;

        double es_dayjfcs = 0.0;
        double es_dayfcs = 0.0;

        double ses_dayjfcs = 0.0;
        double ses_dayfcs = 0.0;

        double s_dayjfcs = 0.0;
        double s_dayfcs = 0.0;

        double sws_dayjfcs = 0.0;
        double sws_dayfcs = 0.0;

        double ws_dayjfcs = 0.0;
        double ws_dayfcs = 0.0;

        double wws_dayjfcs = 0.0;
        double wws_dayfcs = 0.0;


        double w_dayjfcs = 0.0;
        double w_dayfcs = 0.0;

        double wwn_dayjfcs = 0.0;
        double wwn_dayfcs = 0.0;

        double wn_dayjfcs = 0.0;
        double wn_dayfcs = 0.0;

        double nwn_dayjfcs = 0.0;
        double nwn_dayfcs = 0.0;

        List<PointData> fxpointls = new ArrayList<>();
        List<PointData> fspointls = new ArrayList<>();

        if (wt.getWindpowerstationId().contains(WpType.FDC.id)) {
            if (pointmap.containsKey(ContantXk.CJ_FX) && pointmap.containsKey(ContantXk.RPJFS)) {
                ProBasicEquipmentPoint fxpoint = pointmap.get(ContantXk.CJ_FX);
                ProBasicEquipmentPoint fspoint = pointmap.get(ContantXk.RPJFS);
                fxpointls = edosUtil.getHistoryDatasSnap(fxpoint.getNemCode(), begin.getTime() / 1000, end.getTime() / 1000);


                fspointls = edosUtil.getHistoryDatasSnap(fspoint.getNemCode(), begin.getTime() / 1000, end.getTime() / 1000);
            }

        } else {
            if (pointmap.containsKey(ContantXk.CJ_FX) && pointmap.containsKey(ContantXk.RPJGZD)) {
                ProBasicEquipmentPoint fxpoint = pointmap.get(ContantXk.CJ_FX);
                ProBasicEquipmentPoint fspoint = pointmap.get(ContantXk.RPJGZD);
                fxpointls = edosUtil.getHistoryDatasSnap(fxpoint.getNemCode(), begin.getTime() / 1000, end.getTime() / 1000);

                fspointls = edosUtil.getHistoryDatasSnap(fspoint.getNemCode(), begin.getTime() / 1000, end.getTime() / 1000);
            }
        }

        if (!fspointls.isEmpty()) {

            //            //切入切出统计
            //            //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

            double lastvalue = -1;
            for (PointData po : fspointls) {
                //                //小风切入风速
                //               // double xfqr = peiost.getDayInputSmall();

                if (lastvalue != po.getPointValueInDouble()) {
                    //小于小风切入算静风次数累计
                    if (po.getPointValueInDouble() < 3.0) {
                        dayjfcs++;
                        lastvalue = po.getPointValueInDouble();
                    }

                    dayfcs++;
                }

            }

        }


        if (!fxpointls.isEmpty() && !fspointls.isEmpty() && fxpointls.size() == fspointls.size()) {


            for (int i = 0; i < fxpointls.size(); i++) {
                double fx = fxpointls.get(i).getPointValueInDouble();

                double lastfx = -1;
                for (PointData po : fxpointls) {
                    if (lastfx != po.getPointValueInDouble()) {
                        zfxcs++;
                        lastfx = po.getPointValueInDouble();
                    }
                }
                //北
                if ((fx >= 348.76 && fx <= 360) || (fx >= 0 && fx <= 11.25)) {
                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    n_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                n_fsls.add(fspointls.get(i).getPointValueInDouble());
                                n_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                n_dayfcs++;
                            }

                        }

                    }
                }

                //北东北
                else if (fx >= 11.26 && fx <= 33.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    nen_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                nen_fsls.add(fspointls.get(i).getPointValueInDouble());
                                nen_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                nen_dayfcs++;
                            }

                        }

                    }
                }

                //东北
                else if (fx >= 33.76 && fx <= 56.25) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    en_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                en_fsls.add(fspointls.get(i).getPointValueInDouble());
                                en_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                en_dayfcs++;
                            }

                        }

                    }
                }
                //东东北
                else if (fx >= 56.26 && fx <= 78.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    een_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                een_fsls.add(fspointls.get(i).getPointValueInDouble());
                                een_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                een_dayfcs++;
                            }

                        }

                    }
                }
                //东
                else if (fx >= 78.76 && fx <= 101.25) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    e_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                e_fsls.add(fspointls.get(i).getPointValueInDouble());
                                e_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                e_dayfcs++;
                            }

                        }

                    }
                }
                //东东南
                else if (fx >= 101.26 && fx <= 123.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    ees_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                ees_fsls.add(fspointls.get(i).getPointValueInDouble());
                                ees_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                ees_dayfcs++;
                            }

                        }

                    }
                }
                //东南
                else if (fx >= 123.76 && fx <= 146.25) {


                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    es_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                es_fsls.add(fspointls.get(i).getPointValueInDouble());
                                es_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                es_dayfcs++;
                            }

                        }

                    }
                }
                //南东南
                else if (fx >= 146.26 && fx <= 168.75) {


                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    ses_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                ses_fsls.add(fspointls.get(i).getPointValueInDouble());
                                ses_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                ses_dayfcs++;
                            }

                        }

                    }
                }
                //南
                else if (fx >= 168.76 && fx <= 191.25) {


                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    s_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                s_fsls.add(fspointls.get(i).getPointValueInDouble());
                                s_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                s_dayfcs++;
                            }

                        }

                    }
                }
                //南西南
                else if (fx >= 191.26 && fx <= 213.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    sws_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                sws_fsls.add(fspointls.get(i).getPointValueInDouble());
                                sws_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                sws_dayfcs++;
                            }

                        }

                    }
                }
                //西南
                else if (fx >= 213.76 && fx <= 236.25) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    ws_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                ws_fsls.add(fspointls.get(i).getPointValueInDouble());
                                ws_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                ws_dayfcs++;
                            }

                        }

                    }
                }
                //西西南
                else if (fx >= 236.26 && fx <= 258.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    wws_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                wws_fsls.add(fspointls.get(i).getPointValueInDouble());
                                wws_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                wws_dayfcs++;
                            }

                        }

                    }
                }
                //西
                else if (fx >= 258.76 && fx <= 281.25) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    w_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                w_fsls.add(fspointls.get(i).getPointValueInDouble());
                                w_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                w_dayfcs++;
                            }

                        }

                    }
                }
                //西西北
                else if (fx >= 281.26 && fx <= 303.75) {

                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    wwn_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                wwn_fsls.add(fspointls.get(i).getPointValueInDouble());
                                wwn_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                wwn_dayfcs++;
                            }

                        }

                    }
                }
                //西北
                else if (fx >= 303.76 && fx <= 326.25) {


                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    wn_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                wn_fsls.add(fspointls.get(i).getPointValueInDouble());
                                wn_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                wn_dayfcs++;
                            }

                        }

                    }
                }
                //北西北
                else if (fx >= 326.26 && fx <= 348.75) {


                    if (!fspointls.isEmpty()) {
                        //切入切出统计
                        //ProEconInOrOutSpeedTotal peiost = peioomap.get(wt.getId());

                        double lastvalue = -1;
                        for (PointData po : fspointls) {
                            //小风切入风速
                            // double xfqr = peiost.getDayInputSmall();

                            if (lastvalue != po.getPointValueInDouble()) {
                                //小于小风切入算静风次数累计
                                if (po.getPointValueInDouble() < 3.0) {
                                    nwn_dayjfcs++;
                                    lastvalue = po.getPointValueInDouble();
                                }

                                nwn_fsls.add(fspointls.get(i).getPointValueInDouble());
                                nwn_fxls.add(fxpointls.get(i).getPointValueInDouble());

                                nwn_dayfcs++;
                            }

                        }

                    }
                }

            }
        }
        //日静风次数
        pewp.setCa(dayjfcs);
        //日风次数
        pewp.setCh(dayfcs);

        if (dayfcs != 0) {
            pewp.setCb(BigDecimal.valueOf(dayjfcs).divide(new BigDecimal(dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
        }

        //*******************************************************************************************************************/

        if (!e_fsls.isEmpty()) {
            DoubleSummaryStatistics e_ss = e_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setE(e_ss.getAverage());
            //日最大风速
            pewp.setE2(e_ss.getMax());
            //日风向次数
            pewp.setE3((double) e_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setE4(BigDecimal.valueOf(e_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setE4(0.0);
            }

            //日静风次数
            pewp.setE5(e_dayjfcs);

            //日静风频次
            if (e_dayfcs != 0) {
                pewp.setE6(BigDecimal.valueOf(e_dayjfcs).divide(new BigDecimal(e_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }

        //*******************************************************************************************************************/


        if (!ees_fsls.isEmpty()) {
            DoubleSummaryStatistics ese_ss = ees_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setEse(ese_ss.getAverage());
            //日最大风速
            pewp.setEse2(ese_ss.getMax());
            //日风向次数
            pewp.setEse3((double) ees_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setEse4(BigDecimal.valueOf(ees_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setEse4(0.0);
            }

            //日静风次数
            pewp.setEse5(ees_dayjfcs);

            //日静风频次
            if (ees_dayfcs != 0) {
                pewp.setEse6(BigDecimal.valueOf(ees_dayjfcs).divide(new BigDecimal(ees_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!es_fsls.isEmpty()) {
            DoubleSummaryStatistics es_ss = es_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setSe(es_ss.getAverage());
            //日最大风速
            pewp.setSe2(es_ss.getMax());
            //日风向次数
            pewp.setSe3((double) es_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setSe4(BigDecimal.valueOf(es_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setSe4(0.0);
            }

            //日静风次数
            pewp.setSe5(es_dayjfcs);

            //日静风频次
            if (es_dayfcs != 0) {
                pewp.setSe6(BigDecimal.valueOf(es_dayjfcs).divide(new BigDecimal(es_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!ses_fsls.isEmpty()) {
            DoubleSummaryStatistics ses_ss = ses_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setE(ses_ss.getAverage());
            //日最大风速
            pewp.setE2(ses_ss.getMax());
            //日风向次数
            pewp.setE3((double) ses_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setE4(BigDecimal.valueOf(ses_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setE4(0.0);
            }

            //日静风次数
            pewp.setE5(ses_dayjfcs);

            //日静风频次
            if (ses_dayfcs != 0) {
                pewp.setSse(BigDecimal.valueOf(ses_dayjfcs).divide(new BigDecimal(ses_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!s_fsls.isEmpty()) {
            DoubleSummaryStatistics s_ss = s_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setS(s_ss.getAverage());
            //日最大风速
            pewp.setS2(s_ss.getMax());
            //日风向次数
            pewp.setS3((double) s_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setS4(BigDecimal.valueOf(s_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setS4(0.0);
            }
            //日静风次数
            pewp.setS5(s_dayjfcs);

            //日静风频次
            if (s_dayfcs != 0) {
                pewp.setS6(BigDecimal.valueOf(s_dayjfcs).divide(new BigDecimal(s_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!sws_fsls.isEmpty()) {
            DoubleSummaryStatistics sws_ss = sws_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setSse(sws_ss.getAverage());
            //日最大风速
            pewp.setSse2(sws_ss.getMax());
            //日风向次数
            pewp.setSse3((double) sws_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setSse4(BigDecimal.valueOf(sws_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setSse4(0.0);
            }
            //日静风次数
            pewp.setSse5(sws_dayjfcs);

            //日静风频次
            if (sws_dayfcs != 0) {
                pewp.setSse6(BigDecimal.valueOf(sws_dayjfcs).divide(new BigDecimal(sws_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!ws_fsls.isEmpty()) {
            DoubleSummaryStatistics ws_ss = ws_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setSw(ws_ss.getAverage());
            //日最大风速
            pewp.setSw2(ws_ss.getMax());
            //日风向次数
            pewp.setSw3((double) ws_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setSw4(BigDecimal.valueOf(ws_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setSw4(0.0);
            }

            //日静风次数
            pewp.setSw5(ws_dayjfcs);

            //日静风频次
            if (ws_dayfcs != 0) {
                pewp.setSw6(BigDecimal.valueOf(ws_dayjfcs).divide(new BigDecimal(ws_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!wws_fsls.isEmpty()) {
            DoubleSummaryStatistics wws_ss = wws_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setWsw(wws_ss.getAverage());
            //日最大风速
            pewp.setWsw2(wws_ss.getMax());
            //日风向次数
            pewp.setWsw3((double) wws_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setWsw4(BigDecimal.valueOf(wws_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setWsw4(0.0);
            }

            //日静风次数
            pewp.setWsw5(wws_dayjfcs);

            //日静风频次
            if (wws_dayfcs != 0) {
                pewp.setWsw6(BigDecimal.valueOf(wws_dayjfcs).divide(new BigDecimal(wws_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }


        if (!w_fsls.isEmpty()) {
            DoubleSummaryStatistics w_ss = w_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setW(w_ss.getAverage());
            //日最大风速
            pewp.setW2(w_ss.getMax());
            //日风向次数
            pewp.setW3((double) w_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setW4(BigDecimal.valueOf(w_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setW4(0.0);
            }

            //日静风次数
            pewp.setW5(w_dayjfcs);

            //日静风频次
            if (w_dayfcs != 0) {
                pewp.setW6(BigDecimal.valueOf(w_dayjfcs).divide(new BigDecimal(w_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/
        if (!wwn_fsls.isEmpty()) {
            DoubleSummaryStatistics wwn_ss = wwn_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setWnw(wwn_ss.getAverage());
            //日最大风速
            pewp.setWnw2(wwn_ss.getMax());
            //日风向次数
            pewp.setWnw3((double) wwn_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setWnw4(BigDecimal.valueOf(wwn_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setWnw4(0.0);
            }

            //日静风次数
            pewp.setWnw5(wwn_dayjfcs);

            //日静风频次
            if (wwn_dayfcs != 0) {
                pewp.setWnw6(BigDecimal.valueOf(wwn_dayjfcs).divide(new BigDecimal(wwn_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!wn_fsls.isEmpty()) {
            DoubleSummaryStatistics wn_ss = wn_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setNw(wn_ss.getAverage());
            //日最大风速
            pewp.setNw2(wn_ss.getMax());
            //日风向次数
            pewp.setNw3((double) wn_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setNw4(BigDecimal.valueOf(wn_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setNw4(0.0);
            }

            //日静风次数
            pewp.setNw5(wn_dayjfcs);

            //日静风频次
            if (wn_dayfcs != 0) {
                pewp.setNw6(BigDecimal.valueOf(wn_dayjfcs).divide(new BigDecimal(wn_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/


        if (!nwn_fsls.isEmpty()) {
            DoubleSummaryStatistics nwn_ss = nwn_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setNnw(nwn_ss.getAverage());
            //日最大风速
            pewp.setNnw2(nwn_ss.getMax());
            //日风向次数
            pewp.setNnw3((double) nwn_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setNnw4(BigDecimal.valueOf(nwn_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setNnw4(0.0);
            }
            //日静风次数
            pewp.setNnw5(nwn_dayjfcs);

            //日静风频次
            if (nwn_dayfcs != 0) {
                pewp.setNnw6(BigDecimal.valueOf(nwn_dayjfcs).divide(new BigDecimal(nwn_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/


        if (!n_fsls.isEmpty()) {
            DoubleSummaryStatistics n_ss = n_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setN(n_ss.getAverage());
            //日最大风速
            pewp.setN2(n_ss.getMax());
            //日风向次数
            pewp.setN3((double) n_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setN4(BigDecimal.valueOf(n_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setN4(0.0);
            }

            //日静风次数
            pewp.setN5(n_dayjfcs);

            //日静风频次
            if (n_dayfcs != 0) {
                pewp.setN6(BigDecimal.valueOf(n_dayjfcs).divide(new BigDecimal(n_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!nen_fsls.isEmpty()) {
            DoubleSummaryStatistics nen_ss = nen_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setNne(nen_ss.getAverage());
            //日最大风速
            pewp.setNne2(nen_ss.getMax());
            //日风向次数
            pewp.setNne3((double) nen_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setNne4(BigDecimal.valueOf(nen_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setNne4(0.0);
            }

            //日静风次数
            pewp.setNne5(nen_dayjfcs);

            //日静风频次
            if (nen_dayfcs != 0) {
                pewp.setNne6(BigDecimal.valueOf(nen_dayjfcs).divide(new BigDecimal(nen_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/

        if (!en_fsls.isEmpty()) {
            DoubleSummaryStatistics en_ss = en_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setNe(en_ss.getAverage());
            //日最大风速
            pewp.setNe2(en_ss.getMax());
            //日风向次数
            pewp.setNe3((double) en_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setNe4(BigDecimal.valueOf(en_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setNe4(0.0);
            }

            //日静风次数
            pewp.setNe5(en_dayjfcs);

            //日静风频次
            if (en_dayfcs != 0) {
                pewp.setNe6(BigDecimal.valueOf(en_dayjfcs).divide(new BigDecimal(en_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }
        //*******************************************************************************************************************/


        if (!een_fsls.isEmpty()) {
            DoubleSummaryStatistics een_ss = een_fsls.stream().mapToDouble(Double::doubleValue).summaryStatistics();

            //日平均风速
            pewp.setEne(een_ss.getAverage());
            //日最大风速
            pewp.setEne2(een_ss.getMax());
            //日风向次数
            pewp.setEne3((double) een_fxls.size());
            //日风向总次数
            double fpcs = zfxcs;
            if (fpcs != 0) {
                //日风向风频
                pewp.setEne4(BigDecimal.valueOf(een_fxls.size()).divide(new BigDecimal(fpcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            } else {
                pewp.setEne4(0.0);
            }

            //日静风次数
            pewp.setEne5(een_dayjfcs);

            //日静风频次
            if (een_dayfcs != 0) {
                pewp.setEne6(BigDecimal.valueOf(een_dayjfcs).divide(new BigDecimal(een_dayfcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
        }


        //*******************************************日信息统计*********************************************************/

        //*******************************************月信息统计*********************************************************/

        if (pepid1ls.isEmpty()) {
            setInfoMonth(pewp);
        } else {
            ProEconWtwindDayInfo pepid = pepid1ls.get(0);
            //静风次数
            pewp.setCc(pewp.getCc() + pepid.getCa());
            //静风频率
            pewp.setCi(pewp.getCi() + pepid.getCh());
            if (pewp.getCi() != 0) {
                pewp.setCd(BigDecimal.valueOf(pewp.getCc()).divide(new BigDecimal(pewp.getCi()), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }
            //平均风速
            pewp.setE7(BigDecimal.valueOf(pewp.getE7() + pepid.getE()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getE8() && pepid.getE8() > pewp.getE2()) {
                pewp.setE8(pepid.getE8());
            } else {
                pewp.setE8(pewp.getE2());
            }
            //风向次数
            pewp.setE9(pewp.getE3() + pepid.getE9());
            //风向频率
            pewp.setE10(BigDecimal.valueOf(pewp.getE4() + pepid.getE10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setE11(pewp.getE5() + pepid.getE11());
            //静风频率

            double yfxcs = pepid.getCi() + pewp.getCh();
            if (yfxcs != 0) {
                pewp.setE12(BigDecimal.valueOf(pewp.getE11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setEse7(BigDecimal.valueOf(pewp.getEse7() + pepid.getEse()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getEse8() && pepid.getEse8() > pewp.getEse2()) {
                pewp.setEse8(pepid.getEse8());
            } else {
                pewp.setEse8(pewp.getEse2());
            }
            //风向次数
            pewp.setEse9(pewp.getEse3() + pepid.getEse9());
            //风向频率
            pewp.setEse10(BigDecimal.valueOf(pewp.getEse4() + pepid.getEse10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setEse11(pewp.getEse5() + pepid.getEse11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setEse12(BigDecimal.valueOf(pewp.getEse11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setSe7(BigDecimal.valueOf(pewp.getSe7() + pepid.getSe()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSe8() && pepid.getSe8() > pewp.getSe2()) {
                pewp.setSe8(pepid.getSe8());
            } else {
                pewp.setSe8(pewp.getSe2());
            }
            //风向次数
            pewp.setSe9(pewp.getSe3() + pepid.getSe9());
            //风向频率
            pewp.setSe10(BigDecimal.valueOf(pewp.getSe4() + pepid.getSe10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSe11(pewp.getSe5() + pepid.getSe11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSe12(BigDecimal.valueOf(pewp.getSe11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
            //平均风速
            pewp.setS7(BigDecimal.valueOf(pewp.getS7() + pepid.getS()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getS8() && pepid.getS8() > pewp.getS2()) {
                pewp.setS8(pepid.getS8());
            } else {
                pewp.setS8(pewp.getS2());
            }
            //风向次数
            pewp.setS9(pewp.getS3() + pepid.getS9());
            //风向频率
            pewp.setS10(BigDecimal.valueOf(pewp.getS4() + pepid.getS10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setS11(pewp.getS5() + pepid.getS11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setS12(BigDecimal.valueOf(pewp.getS11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setSsw7(BigDecimal.valueOf(pewp.getSsw7() + pepid.getSsw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSsw8() && pepid.getSsw8() > pewp.getSsw2()) {
                pewp.setSsw8(pepid.getSsw8());
            } else {
                pewp.setSsw8(pewp.getSsw2());
            }
            //风向次数
            pewp.setSsw9(pewp.getSsw3() + pepid.getSsw9());
            //风向频率
            pewp.setSsw10(BigDecimal.valueOf(pewp.getSsw4() + pepid.getSsw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSsw11(pewp.getSsw5() + pepid.getSsw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSsw12(BigDecimal.valueOf(pewp.getSsw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setSw7(BigDecimal.valueOf(pewp.getSw7() + pepid.getSw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSw8() && pepid.getSw8() > pewp.getSw2()) {
                pewp.setSw8(pepid.getSw8());
            } else {
                pewp.setSw8(pewp.getSw2());
            }
            //风向次数
            pewp.setSw9(pewp.getSw3() + pepid.getSw9());
            //风向频率
            pewp.setSw10(BigDecimal.valueOf(pewp.getSw4() + pepid.getSw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSw11(pewp.getSw5() + pepid.getSw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSw12(BigDecimal.valueOf(pewp.getSw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
            //平均风速
            pewp.setWsw7(BigDecimal.valueOf(pewp.getWsw7() + pepid.getWsw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getWsw8() && pepid.getWsw8() > pewp.getWsw2()) {
                pewp.setWsw8(pepid.getWsw8());
            } else {
                pewp.setWsw8(pewp.getWsw2());
            }
            //风向次数
            pewp.setWsw9(pewp.getWsw3() + pepid.getWsw9());
            //风向频率
            pewp.setWsw10(BigDecimal.valueOf(pewp.getWsw4() + pepid.getWsw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setWsw11(pewp.getWsw5() + pepid.getWsw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setWsw12(BigDecimal.valueOf(pewp.getWsw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setW7(BigDecimal.valueOf(pewp.getW7() + pepid.getW()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getW8() && pepid.getW8() > pewp.getW2()) {
                pewp.setW8(pepid.getW8());
            } else {
                pewp.setW8(pewp.getW2());
            }
            //风向次数
            pewp.setW9(pewp.getW3() + pepid.getW9());
            //风向频率
            pewp.setW10(BigDecimal.valueOf(pewp.getW4() + pepid.getW10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setW11(pewp.getW5() + pepid.getW11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setW12(BigDecimal.valueOf(pewp.getW11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
            //平均风速
            pewp.setWnw7(BigDecimal.valueOf(pewp.getWnw7() + pepid.getWnw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getWnw8() && pepid.getWnw8() > pewp.getWnw2()) {
                pewp.setWnw8(pepid.getWnw8());
            } else {
                pewp.setWnw8(pewp.getWnw2());
            }
            //风向次数
            pewp.setWnw9(pewp.getWnw3() + pepid.getWnw9());
            //风向频率
            pewp.setWnw10(BigDecimal.valueOf(pewp.getWnw4() + pepid.getWnw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setWnw11(pewp.getWnw5() + pepid.getWnw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setWnw12(BigDecimal.valueOf(pewp.getWnw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
            //平均风速
            pewp.setNw7(BigDecimal.valueOf(pewp.getNw7() + pepid.getNw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNw8() && pepid.getNw8() > pewp.getNw2()) {
                pewp.setNw8(pepid.getNw8());
            } else {
                pewp.setNw8(pewp.getNw2());
            }
            //风向次数
            pewp.setNw9(pewp.getNw3() + pepid.getNw9());
            //风向频率
            pewp.setNw10(BigDecimal.valueOf(pewp.getNw4() + pepid.getNw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNw11(pewp.getNw5() + pepid.getNw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNw12(BigDecimal.valueOf(pewp.getNw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setNnw7(BigDecimal.valueOf(pewp.getNnw7() + pepid.getNnw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNnw8() && pepid.getNnw8() > pewp.getNnw2()) {
                pewp.setNnw8(pepid.getNnw8());
            } else {
                pewp.setNnw8(pewp.getNnw2());
            }
            //风向次数
            pewp.setNnw9(pewp.getNnw3() + pepid.getNnw9());
            //风向频率
            pewp.setNnw10(BigDecimal.valueOf(pewp.getNnw4() + pepid.getNnw10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNnw11(pewp.getNnw5() + pepid.getNnw11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNnw12(BigDecimal.valueOf(pewp.getNnw11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setN7(BigDecimal.valueOf(pewp.getN7() + pepid.getN()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getN8() && pepid.getN8() > pewp.getN2()) {
                pewp.setN8(pepid.getN8());
            } else {
                pewp.setN8(pewp.getN2());
            }
            //风向次数
            pewp.setN9(pewp.getN3() + pepid.getN9());
            //风向频率
            pewp.setN10(BigDecimal.valueOf(pewp.getN4() + pepid.getN10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setN11(pewp.getN5() + pepid.getN11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setN12(BigDecimal.valueOf(pewp.getN11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
            //平均风速
            pewp.setNne7(BigDecimal.valueOf(pewp.getNne7() + pepid.getNne()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNne8() && pepid.getNne8() > pewp.getNne2()) {
                pewp.setNne8(pepid.getNne8());
            } else {
                pewp.setNne8(pewp.getNne2());
            }
            //风向次数
            pewp.setNne9(pewp.getNne3() + pepid.getNne9());
            //风向频率
            pewp.setNne10(BigDecimal.valueOf(pewp.getNne4() + pepid.getNne10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNne11(pewp.getNne5() + pepid.getNne11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNne12(BigDecimal.valueOf(pewp.getNne11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setNe7(BigDecimal.valueOf(pewp.getNe7() + pepid.getNe()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNe8() && pepid.getNe8() > pewp.getNe2()) {
                pewp.setNe8(pepid.getNe8());
            } else {
                pewp.setNe8(pewp.getNe2());
            }
            //风向次数
            pewp.setNe9(pewp.getNe3() + pepid.getNe9());
            //风向频率
            pewp.setNe10(BigDecimal.valueOf(pewp.getNe4() + pepid.getNe10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNe11(pewp.getNe5() + pepid.getNe11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNe12(BigDecimal.valueOf(pewp.getNe11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/

            //平均风速
            pewp.setEne7(BigDecimal.valueOf(pewp.getEne7() + pepid.getEne()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getEne8() && pepid.getEne8() > pewp.getEne2()) {
                pewp.setEne8(pepid.getEne8());
            } else {
                pewp.setEne8(pewp.getEne2());
            }
            //风向次数
            pewp.setEne9(pewp.getEne3() + pepid.getEne9());
            //风向频率
            pewp.setEne10(BigDecimal.valueOf(pewp.getEne4() + pepid.getEne10()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setEne11(pewp.getEne5() + pepid.getEne11());
            //静风频率

            if (yfxcs != 0) {
                pewp.setEne12(BigDecimal.valueOf(pewp.getEne11()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }
            //*******************************************************************************************************************/
        }


        ///*******************************************月信息统计*********************************************************/

        //*******************************************年信息统计*********************************************************/
        if (pepid1ls.isEmpty()) {
            setInfoYear(pewp);
        } else {
            ProEconWtwindDayInfo pepid = pepid1ls.get(0);
            pewp.setCf(pewp.getCf() + pepid.getCa());
            pewp.setCj(pewp.getCj() + pepid.getCh());
            if (pewp.getCj() != 0) {
                pewp.setCg(BigDecimal.valueOf(pewp.getCf()).divide(new BigDecimal(pewp.getCj()), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());
            }

            //平均风速
            pewp.setE13(BigDecimal.valueOf(pewp.getE13() + pepid.getE()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getE14() && pepid.getE14() > pewp.getE2()) {
                pewp.setE14(pepid.getE14());
            } else {
                pewp.setE14(pewp.getE2());
            }
            //风向次数
            pewp.setE15(pewp.getE3() + pepid.getE15());
            //风向频率
            pewp.setE16(BigDecimal.valueOf(pewp.getE6() + pepid.getE16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setE17(pewp.getE5() + pepid.getE17());
            //静风频率

            double yfxcs = pepid.getCj() + pewp.getCh();
            if (yfxcs != 0) {
                pewp.setE18(BigDecimal.valueOf(pewp.getE17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setEse13(BigDecimal.valueOf(pewp.getEse13() + pepid.getEse()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getEse14() && pepid.getEse14() > pewp.getEse2()) {
                pewp.setEse14(pepid.getEse14());
            } else {
                pewp.setEse14(pewp.getEse2());
            }
            //风向次数
            pewp.setEse15(pewp.getEse3() + pepid.getEse15());
            //风向频率
            pewp.setEse16(BigDecimal.valueOf(pewp.getEse6() + pepid.getEse16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setEse17(pewp.getEse5() + pepid.getEse17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setEse18(BigDecimal.valueOf(pewp.getEse17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setSe13(BigDecimal.valueOf(pewp.getSe13() + pepid.getSe()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSe14() && pepid.getSe14() > pewp.getSe2()) {
                pewp.setSe14(pepid.getSe14());
            } else {
                pewp.setSe14(pewp.getSe2());
            }
            //风向次数
            pewp.setSe15(pewp.getSe3() + pepid.getSe15());
            //风向频率
            pewp.setSe16(BigDecimal.valueOf(pewp.getSe6() + pepid.getSe16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSe17(pewp.getSe5() + pepid.getSe17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSe18(BigDecimal.valueOf(pewp.getSe17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setSse13(BigDecimal.valueOf(pewp.getSse13() + pepid.getSse()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSse14() && pepid.getSse14() > pewp.getSse2()) {
                pewp.setSse14(pepid.getSse14());
            } else {
                pewp.setSse14(pewp.getSse2());
            }
            //风向次数
            pewp.setSse15(pewp.getSse3() + pepid.getSse15());
            //风向频率
            pewp.setSse16(BigDecimal.valueOf(pewp.getSse6() + pepid.getSse16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSse17(pewp.getSse5() + pepid.getSse17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSse18(BigDecimal.valueOf(pewp.getSse17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setS13(BigDecimal.valueOf(pewp.getS13() + pepid.getS()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getS14() && pepid.getS14() > pewp.getS2()) {
                pewp.setS14(pepid.getS14());
            } else {
                pewp.setS14(pewp.getS2());
            }
            //风向次数
            pewp.setS15(pewp.getS3() + pepid.getS15());
            //风向频率
            pewp.setS16(BigDecimal.valueOf(pewp.getS6() + pepid.getS16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setS17(pewp.getS5() + pepid.getS17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setS18(BigDecimal.valueOf(pewp.getS17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setSsw13(BigDecimal.valueOf(pewp.getSsw13() + pepid.getSsw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSsw14() && pepid.getSsw14() > pewp.getSsw2()) {
                pewp.setSsw14(pepid.getSsw14());
            } else {
                pewp.setSsw14(pewp.getSsw2());
            }
            //风向次数
            pewp.setSsw15(pewp.getSsw3() + pepid.getSsw15());
            //风向频率
            pewp.setSsw16(BigDecimal.valueOf(pewp.getSsw6() + pepid.getSsw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSsw17(pewp.getSsw5() + pepid.getSsw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSsw18(BigDecimal.valueOf(pewp.getSsw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setSw13(BigDecimal.valueOf(pewp.getSw13() + pepid.getSw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getSw14() && pepid.getSw14() > pewp.getSw2()) {
                pewp.setSw14(pepid.getSw14());
            } else {
                pewp.setSw14(pewp.getSw2());
            }
            //风向次数
            pewp.setSw15(pewp.getSw3() + pepid.getSw15());
            //风向频率
            pewp.setSw16(BigDecimal.valueOf(pewp.getSw6() + pepid.getSw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setSw17(pewp.getSw5() + pepid.getSw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setSw18(BigDecimal.valueOf(pewp.getSw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setWsw13(BigDecimal.valueOf(pewp.getWsw13() + pepid.getWsw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getWsw14() && pepid.getWsw14() > pewp.getWsw2()) {
                pewp.setWsw14(pepid.getWsw14());
            } else {
                pewp.setWsw14(pewp.getWsw2());
            }
            //风向次数
            pewp.setWsw15(pewp.getWsw3() + pepid.getWsw15());
            //风向频率
            pewp.setWsw16(BigDecimal.valueOf(pewp.getWsw6() + pepid.getWsw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setWsw17(pewp.getWsw5() + pepid.getWsw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setWsw18(BigDecimal.valueOf(pewp.getWsw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setW13(BigDecimal.valueOf(pewp.getW13() + pepid.getW()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getW14() && pepid.getW14() > pewp.getW2()) {
                pewp.setW14(pepid.getW14());
            } else {
                pewp.setW14(pewp.getW2());
            }
            //风向次数
            pewp.setW15(pewp.getW3() + pepid.getW15());
            //风向频率
            pewp.setW16(BigDecimal.valueOf(pewp.getW6() + pepid.getW16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setW17(pewp.getW5() + pepid.getW17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setW18(BigDecimal.valueOf(pewp.getW17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setWnw13(BigDecimal.valueOf(pewp.getWnw13() + pepid.getWnw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getWnw14() && pepid.getWnw14() > pewp.getWnw2()) {
                pewp.setWnw14(pepid.getWnw14());
            } else {
                pewp.setWnw14(pewp.getWnw2());
            }
            //风向次数
            pewp.setWnw15(pewp.getWnw3() + pepid.getWnw15());
            //风向频率
            pewp.setWnw16(BigDecimal.valueOf(pewp.getWnw6() + pepid.getWnw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setWnw17(pewp.getWnw5() + pepid.getWnw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setWnw18(BigDecimal.valueOf(pewp.getWnw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setNw13(BigDecimal.valueOf(pewp.getNw13() + pepid.getNw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNw14() && pepid.getNw14() > pewp.getNw2()) {
                pewp.setNw14(pepid.getNw14());
            } else {
                pewp.setNw14(pewp.getNw2());
            }
            //风向次数
            pewp.setNw15(pewp.getNw3() + pepid.getNw15());
            //风向频率
            pewp.setNw16(BigDecimal.valueOf(pewp.getNw6() + pepid.getNw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNw17(pewp.getNw5() + pepid.getNw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNw18(BigDecimal.valueOf(pewp.getNw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setNnw13(BigDecimal.valueOf(pewp.getNnw13() + pepid.getNnw()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNnw14() && pepid.getNnw14() > pewp.getNnw2()) {
                pewp.setNnw14(pepid.getNnw14());
            } else {
                pewp.setNnw14(pewp.getNnw2());
            }
            //风向次数
            pewp.setNnw15(pewp.getNnw3() + pepid.getNnw15());
            //风向频率
            pewp.setNnw16(BigDecimal.valueOf(pewp.getNnw6() + pepid.getNnw16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNnw17(pewp.getNnw5() + pepid.getNnw17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNnw18(BigDecimal.valueOf(pewp.getNnw17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setN13(BigDecimal.valueOf(pewp.getN13() + pepid.getN()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getN14() && pepid.getN14() > pewp.getN2()) {
                pewp.setN14(pepid.getN14());
            } else {
                pewp.setN14(pewp.getN2());
            }
            //风向次数
            pewp.setN15(pewp.getN3() + pepid.getN15());
            //风向频率
            pewp.setN16(BigDecimal.valueOf(pewp.getN6() + pepid.getN16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setN17(pewp.getN5() + pepid.getN17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setN18(BigDecimal.valueOf(pewp.getN17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setNne13(BigDecimal.valueOf(pewp.getNne13() + pepid.getNne()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNne14() && pepid.getNne14() > pewp.getNne2()) {
                pewp.setNne14(pepid.getNne14());
            } else {
                pewp.setNne14(pewp.getNne2());
            }
            //风向次数
            pewp.setNne15(pewp.getNne3() + pepid.getNne15());
            //风向频率
            pewp.setNne16(BigDecimal.valueOf(pewp.getNne6() + pepid.getNne16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNne17(pewp.getNne5() + pepid.getNne17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNne18(BigDecimal.valueOf(pewp.getNne17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setNe13(BigDecimal.valueOf(pewp.getNe13() + pepid.getNe()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getNe14() && pepid.getNe14() > pewp.getNe2()) {
                pewp.setNe14(pepid.getNe14());
            } else {
                pewp.setNe14(pewp.getNe2());
            }
            //风向次数
            pewp.setNe15(pewp.getNe3() + pepid.getNe15());
            //风向频率
            pewp.setNe16(BigDecimal.valueOf(pewp.getNe6() + pepid.getNe16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setNe17(pewp.getNe5() + pepid.getNe17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setNe18(BigDecimal.valueOf(pewp.getNe17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
            //平均风速
            pewp.setEne13(BigDecimal.valueOf(pewp.getEne13() + pepid.getEne()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //最大风速
            if (null != pepid.getEne14() && pepid.getEne14() > pewp.getEne2()) {
                pewp.setEne14(pepid.getEne14());
            } else {
                pewp.setEne14(pewp.getEne2());
            }
            //风向次数
            pewp.setEne15(pewp.getEne3() + pepid.getEne15());
            //风向频率
            pewp.setEne16(BigDecimal.valueOf(pewp.getEne6() + pepid.getEne16()).divide(new BigDecimal(2), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            //静风次数
            pewp.setEne17(pewp.getEne5() + pepid.getEne17());
            //静风频率

            if (yfxcs != 0) {
                pewp.setEne18(BigDecimal.valueOf(pewp.getEne17()).divide(new BigDecimal(yfxcs), 2, RoundingMode.HALF_EVEN).multiply(new BigDecimal(100)).doubleValue());

            }

            //*******************************************************************************************************************/
        }


    }


    private void setInfoMonth(ProEconWtwindDayInfo po) {
        po.setCc(po.getCa());
        po.setCd(po.getCb());
        po.setE7(po.getE());
        po.setEse7(po.getEse());
        po.setSe7(po.getSe());
        po.setSse7(po.getSse());
        po.setS7(po.getS());
        po.setSsw7(po.getSsw());
        po.setSw7(po.getSw());
        po.setWsw7(po.getWsw());
        po.setW7(po.getW());
        po.setWnw7(po.getWnw());
        po.setNw7(po.getNw());
        po.setNnw7(po.getNnw());
        po.setN7(po.getN());
        po.setNne7(po.getNne());
        po.setNe7(po.getNe());
        po.setEne7(po.getEne());

        po.setE8(po.getE2());
        po.setEse8(po.getEse2());
        po.setSe8(po.getSe2());
        po.setSse8(po.getSse2());
        po.setS8(po.getS2());
        po.setSsw8(po.getSsw2());
        po.setSw8(po.getSw2());
        po.setWsw8(po.getWsw2());
        po.setW8(po.getW2());
        po.setWnw8(po.getWnw2());
        po.setNw8(po.getNw2());
        po.setNnw8(po.getNnw2());
        po.setN8(po.getN2());
        po.setNne8(po.getNne2());
        po.setNe8(po.getNe2());
        po.setEne8(po.getEne2());

        po.setE9(po.getE3());
        po.setEse9(po.getEse3());
        po.setSe9(po.getSe3());
        po.setSse9(po.getSse3());
        po.setS9(po.getS3());
        po.setSsw9(po.getSsw3());
        po.setSw9(po.getSw3());
        po.setWsw9(po.getWsw3());
        po.setW9(po.getW3());
        po.setWnw9(po.getWnw3());
        po.setNw9(po.getNw3());
        po.setNnw9(po.getNnw3());
        po.setN9(po.getN3());
        po.setNne9(po.getNne3());
        po.setNe9(po.getNe3());
        po.setEne9(po.getEne3());

        po.setE10(po.getE4());
        po.setEse10(po.getEse4());
        po.setSe10(po.getSe4());
        po.setSse10(po.getSse4());
        po.setS10(po.getS4());
        po.setSsw10(po.getSsw4());
        po.setSw10(po.getSw4());
        po.setWsw10(po.getWsw4());
        po.setW10(po.getW4());
        po.setWnw10(po.getWnw4());
        po.setNw10(po.getNw4());
        po.setNnw10(po.getNnw4());
        po.setN10(po.getN4());
        po.setNne10(po.getNne4());
        po.setNe10(po.getNe4());
        po.setEne10(po.getEne4());

        po.setE11(po.getE5());
        po.setEse11(po.getEse5());
        po.setSe11(po.getSe5());
        po.setSse11(po.getSse5());
        po.setS11(po.getS5());
        po.setSsw11(po.getSsw5());
        po.setSw11(po.getSw5());
        po.setWsw11(po.getWsw5());
        po.setW11(po.getW5());
        po.setWnw11(po.getWnw5());
        po.setNw11(po.getNw5());
        po.setNnw11(po.getNnw5());
        po.setN11(po.getN5());
        po.setNne11(po.getNne5());
        po.setNe11(po.getNe5());
        po.setEne11(po.getEne5());

        po.setE12(po.getE6());
        po.setEse12(po.getEse6());
        po.setSe12(po.getSe6());
        po.setSse12(po.getSse6());
        po.setS12(po.getS6());
        po.setSsw12(po.getSsw6());
        po.setSw12(po.getSw6());
        po.setWsw12(po.getWsw6());
        po.setW12(po.getW6());
        po.setWnw12(po.getWnw6());
        po.setNw12(po.getNw6());
        po.setNnw12(po.getNnw6());
        po.setN12(po.getN6());
        po.setNne12(po.getNne6());
        po.setNe12(po.getNe6());
        po.setEne12(po.getEne6());
    }

    private void setInfoYear(ProEconWtwindDayInfo po) {
        po.setCf(po.getCa());
        po.setCg(po.getCb());
        po.setE13(po.getE());
        po.setEse13(po.getEse());
        po.setSe13(po.getSe());
        po.setSse13(po.getSse());
        po.setS13(po.getS());
        po.setSsw13(po.getSsw());
        po.setSw13(po.getSw());
        po.setWsw13(po.getWsw());
        po.setW13(po.getW());
        po.setWnw13(po.getWnw());
        po.setNw13(po.getNw());
        po.setNnw13(po.getNnw());
        po.setN13(po.getN());
        po.setNne13(po.getNne());
        po.setNe13(po.getNe());
        po.setEne13(po.getEne());

        po.setE14(po.getE2());
        po.setEse14(po.getEse2());
        po.setSe14(po.getSe2());
        po.setSse14(po.getSse2());
        po.setS14(po.getS2());
        po.setSsw14(po.getSsw2());
        po.setSw14(po.getSw2());
        po.setWsw14(po.getWsw2());
        po.setW14(po.getW2());
        po.setWnw14(po.getWnw2());
        po.setNw14(po.getNw2());
        po.setNnw14(po.getNnw2());
        po.setN14(po.getN2());
        po.setNne14(po.getNne2());
        po.setNe14(po.getNe2());
        po.setEne14(po.getEne2());

        po.setE15(po.getE3());
        po.setEse15(po.getEse3());
        po.setSe15(po.getSe3());
        po.setSse15(po.getSse3());
        po.setS15(po.getS3());
        po.setSsw15(po.getSsw3());
        po.setSw15(po.getSw3());
        po.setWsw15(po.getWsw3());
        po.setW15(po.getW3());
        po.setWnw15(po.getWnw3());
        po.setNw15(po.getNw3());
        po.setNnw15(po.getNnw3());
        po.setN15(po.getN3());
        po.setNne15(po.getNne3());
        po.setNe15(po.getNe3());
        po.setEne15(po.getEne3());

        po.setE16(po.getE4());
        po.setEse16(po.getEse4());
        po.setSe16(po.getSe4());
        po.setSse16(po.getSse4());
        po.setS16(po.getS4());
        po.setSsw16(po.getSsw4());
        po.setSw16(po.getSw4());
        po.setWsw16(po.getWsw4());
        po.setW16(po.getW4());
        po.setWnw16(po.getWnw4());
        po.setNw16(po.getNw4());
        po.setNnw16(po.getNnw4());
        po.setN16(po.getN4());
        po.setNne16(po.getNne4());
        po.setNe16(po.getNe4());
        po.setEne16(po.getEne4());

        po.setE17(po.getE5());
        po.setEse17(po.getEse5());
        po.setSe17(po.getSe5());
        po.setSse17(po.getSse5());
        po.setS17(po.getS5());
        po.setSsw17(po.getSsw5());
        po.setSw17(po.getSw5());
        po.setWsw17(po.getWsw5());
        po.setW17(po.getW5());
        po.setWnw17(po.getWnw5());
        po.setNw17(po.getNw5());
        po.setNnw17(po.getNnw5());
        po.setN17(po.getN5());
        po.setNne17(po.getNne5());
        po.setNe17(po.getNe5());
        po.setEne17(po.getEne5());

        po.setE18(po.getE6());
        po.setEse18(po.getEse6());
        po.setSe18(po.getSe6());
        po.setSse18(po.getSse6());
        po.setS18(po.getS6());
        po.setSsw18(po.getSsw6());
        po.setSw18(po.getSw6());
        po.setWsw18(po.getWsw6());
        po.setW18(po.getW6());
        po.setWnw18(po.getWnw6());
        po.setNw18(po.getNw6());
        po.setNnw18(po.getNnw6());
        po.setN18(po.getN6());
        po.setNne18(po.getNne6());
        po.setNe18(po.getNe6());
        po.setEne18(po.getEne6());

    }

    private void initial(ProEconWtwindDayInfo po) {
        po.setCa(0.0);

        po.setCb(0.0);

        po.setCc(0.0);

        po.setCd(0.0);

        po.setCf(0.0);

        po.setCg(0.0);

        po.setE(0.0);

        po.setEse(0.0);

        po.setSe(0.0);

        po.setSse(0.0);

        po.setS(0.0);

        po.setSsw(0.0);

        po.setSw(0.0);

        po.setWsw(0.0);

        po.setW(0.0);

        po.setWnw(0.0);

        po.setNw(0.0);

        po.setNnw(0.0);

        po.setN(0.0);

        po.setNne(0.0);

        po.setNe(0.0);

        po.setEne(0.0);

        po.setE2(0.0);

        po.setEse2(0.0);

        po.setSe2(0.0);

        po.setSse2(0.0);

        po.setS2(0.0);

        po.setSsw2(0.0);

        po.setSw2(0.0);

        po.setWsw2(0.0);

        po.setW2(0.0);

        po.setWnw2(0.0);

        po.setNw2(0.0);

        po.setNnw2(0.0);

        po.setN2(0.0);

        po.setNne2(0.0);

        po.setNe2(0.0);

        po.setEne2(0.0);

        po.setE3(0.0);

        po.setEse3(0.0);

        po.setSe3(0.0);

        po.setSse3(0.0);

        po.setS3(0.0);

        po.setSsw3(0.0);

        po.setSw3(0.0);

        po.setWsw3(0.0);

        po.setW3(0.0);

        po.setWnw3(0.0);

        po.setNw3(0.0);

        po.setNnw3(0.0);

        po.setN3(0.0);

        po.setNne3(0.0);

        po.setNe3(0.0);

        po.setEne3(0.0);

        po.setE4(0.0);

        po.setEse4(0.0);

        po.setSe4(0.0);

        po.setSse4(0.0);

        po.setS4(0.0);

        po.setSsw4(0.0);

        po.setSw4(0.0);

        po.setWsw4(0.0);

        po.setW4(0.0);

        po.setWnw4(0.0);

        po.setNw4(0.0);

        po.setNnw4(0.0);

        po.setN4(0.0);

        po.setNne4(0.0);

        po.setNe4(0.0);

        po.setEne4(0.0);

        po.setE5(0.0);

        po.setEse5(0.0);

        po.setSe5(0.0);

        po.setSse5(0.0);

        po.setS5(0.0);

        po.setSsw5(0.0);

        po.setSw5(0.0);

        po.setWsw5(0.0);

        po.setW5(0.0);

        po.setWnw5(0.0);

        po.setNw5(0.0);

        po.setNnw5(0.0);

        po.setN5(0.0);

        po.setNne5(0.0);

        po.setNe5(0.0);

        po.setEne5(0.0);

        po.setE6(0.0);

        po.setEse6(0.0);

        po.setSe6(0.0);

        po.setSse6(0.0);

        po.setS6(0.0);

        po.setSsw6(0.0);

        po.setSw6(0.0);

        po.setWsw6(0.0);

        po.setW6(0.0);

        po.setWnw6(0.0);

        po.setNw6(0.0);

        po.setNnw6(0.0);

        po.setN6(0.0);

        po.setNne6(0.0);

        po.setNe6(0.0);

        po.setEne6(0.0);

        po.setE7(0.0);

        po.setEse7(0.0);

        po.setSe7(0.0);

        po.setSse7(0.0);

        po.setS7(0.0);

        po.setSsw7(0.0);

        po.setSw7(0.0);

        po.setWsw7(0.0);

        po.setW7(0.0);

        po.setWnw7(0.0);

        po.setNw7(0.0);

        po.setNnw7(0.0);

        po.setN7(0.0);

        po.setNne7(0.0);

        po.setNe7(0.0);

        po.setEne7(0.0);

        po.setE8(0.0);

        po.setEse8(0.0);

        po.setSe8(0.0);

        po.setSse8(0.0);

        po.setS8(0.0);

        po.setSsw8(0.0);

        po.setSw8(0.0);

        po.setWsw8(0.0);

        po.setW8(0.0);

        po.setWnw8(0.0);

        po.setNw8(0.0);

        po.setNnw8(0.0);

        po.setN8(0.0);

        po.setNne8(0.0);

        po.setNe8(0.0);

        po.setEne8(0.0);

        po.setE9(0.0);

        po.setEse9(0.0);

        po.setSe9(0.0);

        po.setSse9(0.0);

        po.setS9(0.0);

        po.setSsw9(0.0);

        po.setSw9(0.0);

        po.setWsw9(0.0);

        po.setW9(0.0);

        po.setWnw9(0.0);

        po.setNw9(0.0);

        po.setNnw9(0.0);

        po.setN9(0.0);

        po.setNne9(0.0);

        po.setNe9(0.0);

        po.setEne9(0.0);

        po.setE10(0.0);

        po.setEse10(0.0);

        po.setSe10(0.0);

        po.setSse10(0.0);

        po.setS10(0.0);

        po.setSsw10(0.0);

        po.setSw10(0.0);

        po.setWsw10(0.0);

        po.setW10(0.0);

        po.setWnw10(0.0);

        po.setNw10(0.0);

        po.setNnw10(0.0);

        po.setN10(0.0);

        po.setNne10(0.0);

        po.setNe10(0.0);

        po.setEne10(0.0);

        po.setE11(0.0);

        po.setEse11(0.0);

        po.setSe11(0.0);

        po.setSse11(0.0);

        po.setS11(0.0);

        po.setSsw11(0.0);

        po.setSw11(0.0);

        po.setWsw11(0.0);

        po.setW11(0.0);

        po.setWnw11(0.0);

        po.setNw11(0.0);

        po.setNnw11(0.0);

        po.setN11(0.0);

        po.setNne11(0.0);

        po.setNe11(0.0);

        po.setEne11(0.0);

        po.setE12(0.0);

        po.setEse12(0.0);

        po.setSe12(0.0);

        po.setSse12(0.0);

        po.setS12(0.0);

        po.setSsw12(0.0);

        po.setSw12(0.0);

        po.setWsw12(0.0);

        po.setW12(0.0);

        po.setWnw12(0.0);

        po.setNw12(0.0);

        po.setNnw12(0.0);

        po.setN12(0.0);

        po.setNne12(0.0);

        po.setNe12(0.0);

        po.setEne12(0.0);

        po.setE13(0.0);

        po.setEse13(0.0);

        po.setSe13(0.0);

        po.setSse13(0.0);

        po.setS13(0.0);

        po.setSsw13(0.0);

        po.setSw13(0.0);

        po.setWsw13(0.0);

        po.setW13(0.0);

        po.setWnw13(0.0);

        po.setNw13(0.0);

        po.setNnw13(0.0);

        po.setN13(0.0);

        po.setNne13(0.0);

        po.setNe13(0.0);

        po.setEne13(0.0);

        po.setE14(0.0);

        po.setEse14(0.0);

        po.setSe14(0.0);

        po.setSse14(0.0);

        po.setS14(0.0);

        po.setSsw14(0.0);

        po.setSw14(0.0);

        po.setWsw14(0.0);

        po.setW14(0.0);

        po.setWnw14(0.0);

        po.setNw14(0.0);

        po.setNnw14(0.0);

        po.setN14(0.0);

        po.setNne14(0.0);

        po.setNe14(0.0);

        po.setEne14(0.0);

        po.setE15(0.0);

        po.setEse15(0.0);

        po.setSe15(0.0);

        po.setSse15(0.0);

        po.setS15(0.0);

        po.setSsw15(0.0);

        po.setSw15(0.0);

        po.setWsw15(0.0);

        po.setW15(0.0);

        po.setWnw15(0.0);

        po.setNw15(0.0);

        po.setNnw15(0.0);

        po.setN15(0.0);

        po.setNne15(0.0);

        po.setNe15(0.0);

        po.setEne15(0.0);

        po.setE16(0.0);

        po.setEse16(0.0);

        po.setSe16(0.0);

        po.setSse16(0.0);

        po.setS16(0.0);

        po.setSsw16(0.0);

        po.setSw16(0.0);

        po.setWsw16(0.0);

        po.setW16(0.0);

        po.setWnw16(0.0);

        po.setNw16(0.0);

        po.setNnw16(0.0);

        po.setN16(0.0);

        po.setNne16(0.0);

        po.setNe16(0.0);

        po.setEne16(0.0);

        po.setE17(0.0);

        po.setEse17(0.0);

        po.setSe17(0.0);

        po.setSse17(0.0);

        po.setS17(0.0);

        po.setSsw17(0.0);

        po.setSw17(0.0);

        po.setWsw17(0.0);

        po.setW17(0.0);

        po.setWnw17(0.0);

        po.setNw17(0.0);

        po.setNnw17(0.0);

        po.setN17(0.0);

        po.setNne17(0.0);

        po.setNe17(0.0);

        po.setEne17(0.0);

        po.setE18(0.0);

        po.setEse18(0.0);

        po.setSe18(0.0);

        po.setSse18(0.0);

        po.setS18(0.0);

        po.setSsw18(0.0);

        po.setSw18(0.0);

        po.setWsw18(0.0);

        po.setW18(0.0);

        po.setWnw18(0.0);

        po.setNw18(0.0);

        po.setNnw18(0.0);

        po.setN18(0.0);

        po.setNne18(0.0);

        po.setNe18(0.0);

        po.setEne18(0.0);

        po.setCh(0.0);

        po.setCi(0.0);

        po.setCj(0.0);
    }
}







