metradar 0.1.5__py3-none-any.whl → 0.1.8__py3-none-any.whl

metradar/grid.py

@@ -1,281 +0,0 @@
-import math
-import datetime
-import re
-from copy import deepcopy
-import numpy as np
-
-class grid:
-    '''
-        定义一个格点的类grid，来存储网格的范围包括（起始经纬度、格距、起止时间，时间间隔，起止时效，时效间隔，层次列表，数据成员）
-        约定坐标顺序为: member, time,ddtime, level, lat,lon
-    '''
-    def __init__(self,glon, glat, gtime=None, dtime_list=None,level_list=None,member_list = None):
-
-        #提取成员维度信息
-        if(member_list is None):
-            self.members =['data0']
-        else:
-            self.members = member_list
-        ############################################################################
-        #提取层次维度信息
-        if(level_list is None):
-            self.levels =[0]
-        else:
-            self.levels = level_list
-        ############################################################################
-        #提取时间维度信息
-        self.stime = np.datetime64('2099-01-01T00:00:00.000000')
-        self.etime = np.datetime64('2099-01-01T00:00:00.000000')
-        self.dtime_int = 1
-        self.dtime_type = "h"
-        self.dtimedelta = np.timedelta64(1,'h')
-        if(gtime == None):gtime = []
-        if len(gtime) == 1:
-            if type(gtime[0]) == str:
-                num = ''.join([x for x in gtime[0] if x.isdigit()])
-                # 用户输入2019041910十位字符，后面补全加0000，为14位统一处理
-                if len(num) == 4:
-                    num += "0101000000"
-                elif len(num) == 6:
-                    num +="01000000"
-                elif len(num) == 8:
-                    num +="000000"
-                elif len(num) == 10:
-                    num +="0000"
-                elif len(num) == 12:
-                    num +="00"
-                elif len(num) == 14:
-                    pass
-                else:
-                    print("输入日期有误，请检查！")
-                # 统一将日期变为datetime类型
-                self.stime = datetime.datetime.strptime(num, '%Y%m%d%H%M%S')
-                self.etime = datetime.datetime.strptime(num, '%Y%m%d%H%M%S')
-                self.stime = np.datetime64(self.stime)
-                self.etime = np.datetime64(self.etime)
-            else:
-                self.stime = gtime[0]
-                self.etime = gtime[0]
-            self.dtime_int = 1
-            self.dtime_type = "h"
-            self.dtimedelta = np.timedelta64(0,'h')
-        elif len(gtime) ==3:
-            num1 =[]
-            if type(gtime[0]) == str:
-                for i in range (0,2):
-                    num = ''.join([x for x in gtime[i] if x.isdigit()])
-                    #用户输入2019041910十位字符，后面补全加0000，为14位统一处理
-                    if len(num) == 4:
-                        num1.append(num + "0101000000")
-                    elif len(num) == 6:
-                        num1.append(num + "01000000")
-                    elif len(num) == 8:
-                        num1.append(num + "000000")
-                    elif len(num) == 10:
-                        num1.append(num + "0000")
-                    elif len(num) == 12:
-                        num1.append(num + "00")
-                    elif len(num) == 14:
-                        num1.append(num)
-                    else:
-                        print("输入日期有误，请检查！")
-                    #统一将日期变为datetime类型
-                #print(num1)
-                self.stime = datetime.datetime.strptime(num1[0], '%Y%m%d%H%M%S')
-                self.etime = datetime.datetime.strptime(num1[1], '%Y%m%d%H%M%S')
-                self.stime = np.datetime64(self.stime)
-                self.etime = np.datetime64(self.etime)
-            elif isinstance(gtime[0],np.datetime64):
-                stime = gtime[0].astype(datetime.datetime)
-                etime = gtime[1].astype(datetime.datetime)
-                if isinstance(stime, int):
-                    stime = datetime.datetime.utcfromtimestamp(stime / 1000000000)
-                    etime = datetime.datetime.utcfromtimestamp(etime / 1000000000)
-                self.stime = stime
-                self.etime = etime
-            else:
-                self.stime = gtime[0]
-                self.etime = gtime[1]
-
-            if type(gtime[2]) == str:
-                self.dtime_int = re.findall(r"\d+", gtime[2])[0]
-                dtime_type = re.findall(r"\D+", gtime[2])[0]
-                if dtime_type == 'h':
-                    self.dtime_type ="h"
-                    self.dtimedelta = np.timedelta64(self.dtime_int,'h')
-                elif dtime_type == 'd':
-                    self.dtime_type ="D"
-                    self.dtimedelta = np.timedelta64(self.dtime_int, 'D')
-                elif dtime_type == 'm':
-                    self.dtime_type ="m"
-                    self.dtimedelta = np.timedelta64(self.dtime_int, 'm')
-            elif isinstance(gtime[2],np.timedelta64):
-                seconds = int(gtime[2] / np.timedelta64(1, 's'))
-                if seconds % 3600 == 0:
-                    self.dtime_type = "h"
-                    self.dtime_int = int(seconds / 3600)
-                else:
-                    self.dtime_type = "m"
-                    self.dtime_int = int(seconds / 60)
-            else:
-                self.dtimedelta = gtime[2]
-                seconds = gtime[2].total_seconds()
-                if seconds % 3600 == 0:
-                    self.dtime_type = "h"
-                    self.dtime_int = int(seconds/3600)
-                else:
-                    self.dtime_type = "m"
-                    self.dtime_int = int(seconds / 60)
-        self.gtime = [self.stime,self.etime,str(self.dtime_int) + self.dtime_type]
-        self.stime_str = str(self.stime).replace("-","").replace(" ","").replace(":","").replace("T","")[0:14]
-        self.etime_str = str(self.etime).replace("-", "").replace(" ", "").replace(":", "").replace("T", "")[0:14]
-        self.dtime_str = str(self.dtime_int) + self.dtime_type
-
-        ############################################################################
-        #提取预报时效维度信息
-        if dtime_list is None:
-            self.dtimes = [0]
-        else:
-            self.dtimes = dtime_list
-        ############################################################################
-        #提取经度信息
-
-        self.slon = get_true_value(glon[0])
-        self.elon = get_true_value(glon[1])
-        self.dlon = get_true_value(glon[2])
-        nlon = 1 + (self.elon - self.slon) / self.dlon
-        error = abs(round(nlon) - nlon)/nlon
-        if (error > 0.01):
-            self.nlon = int(math.ceil(nlon))
-        else:
-            self.nlon = int(round(nlon))
-
-        self.elon = get_true_value(self.slon + (nlon - 1) * self.dlon)
-        self.glon = [self.slon,self.elon,self.dlon]
-
-        ############################################################################
-        #提取纬度信息
-        self.slat = get_true_value(glat[0])
-        self.elat = get_true_value(glat[1])
-        self.dlat = get_true_value(glat[2])
-        nlat = 1 + (self.elat - self.slat) / self.dlat
-        error = abs(round(nlat) - nlat)/nlat
-        if (error > 0.01):
-            self.nlat = int(math.ceil(nlat))
-        else:
-            self.nlat = int(round(nlat))
-        self.elat = get_true_value(self.slat + (nlat - 1) * self.dlat)
-        self.glat = [self.slat,self.elat,self.dlat]
-
-
-
-    #对原有的格点数据进行一次深拷贝，不改变原有的值和结构。
-    def copy(self):
-        return deepcopy(self)
-
-    #reset的作用是把网格的坐标间隔统一为正数。
-    def reset(self):
-        if (self.dlon > 0 and self.dlat > 0):
-            pass
-        if (self.dlat < 0):
-            tran = self.slat
-            self.slat = self.elat
-            self.elat = tran
-            self.dlat = abs(self.dlat)
-        if (self.dlon < 0):
-            tran = self.slon
-            self.slon = self.elon
-            self.elon = tran
-            self.dlon = abs(self.dlon)
-        return
-
-
-    def __str__(self):
-        '''
-        重置系统自动的函数，在print(grid) 的时候可以很整齐的看到所有信息
-        :return:  string
-        '''
-        grid_str = ""
-        grid_str += "members:" + str(self.members) +"\n"
-        grid_str += "levels:" + str(self.levels) + "\n"
-        grid_str += "gtime:" + str([self.stime_str,self.etime_str,self.dtime_str]) + "\n"
-        grid_str += "dtimes:" + str(self.dtimes)  +"\n"
-        grid_str += "glon:" + str(self.glon) + "\n"
-        grid_str += "glat:" + str(self.glat) + "\n"
-        return grid_str
-
-def get_true_value(value):
-    dlon2 = round(value, 2)
-    dlon3 = round(value, 3)
-    dlon4 = round(value, 4)
-    dlon5 = round(value, 5)
-    if dlon2 == dlon3 and dlon3 == dlon4:
-        return dlon3
-    elif dlon3 == dlon4 and dlon5 == dlon4:
-        return dlon3
-    else:
-        return value
-
-
-def get_grid_of_data(grid_data0):
-    '''
-     获取grid的数据values值
-    :param grid_data0:初始化之后的网格数据
-    :return:返回grid数据。
-    '''
-    member_list = grid_data0['member'].values
-    level_list = grid_data0['level'].values
-    times = grid_data0['time'].values
-    #print(times)
-    if(len(times)>1):
-        gtime = [times[0],times[-1],times[1]-times[0]]
-    elif len(times) == 1:
-        gtime = times
-    else:
-        gtime = None
-
-    gdt = grid_data0['dtime'].values.tolist()
-    attrs_name = list(grid_data0.attrs)
-
-
-    lons = grid_data0['lon'].values
-
-    #dlon5 = round(lons[1] - lons[0], 5)
-    #dlon6 = round(lons[1] - lons[0], 6)
-    #dlon7 = round(lons[1] - lons[0], 7)
-    #if dlon5 == dlon6 and dlon6 == dlon7:
-    #    dlon = dlon5
-    #else:
-    #    dlon = lons[1]-lons[0]
-    dlon = get_true_value(lons[1] - lons[0])
-
-    #glon = [lons[0],round(lons[-1],5),round(lons[1]-lons[0],5)]
-    glon = [get_true_value(lons[0]), get_true_value(lons[-1]), dlon]
-    lats = grid_data0['lat'].values
-    #dlat5 = round(lats[1] - lats[0], 5)
-    #dlat6 = round(lats[1] - lats[0], 6)
-    #dlat7 = round(lats[1] - lats[0], 7)
-    #if dlat5 == dlat6 and dlat6 == dlat7:
-    #    dlat = dlat5
-    #else:
-    #    dlat = lats[1]-lats[0]
-    dlat = get_true_value(lats[1] - lats[0])
-
-    #glat = [lats[0],round(lats[-1],5),round(lats[1]-lats[0],5)]
-    glat = [get_true_value(lats[0]), get_true_value(lats[-1]), dlat]
-    grid01 = grid(glon, glat, gtime, gdt, level_list, member_list)
-    return grid01
-
-
-def reset_grid(grid0):
-    if grid0.dlat <0:
-        grid0.dlat = - grid0.dlat
-        tran = grid0.slat
-        grid0.slat = grid0.elat
-        grid0.elat = tran
-    if grid0.dlon <0:
-        grid0.dlon = - grid0.dlon
-        tran = grid0.slon
-        grid0.slon = grid0.elon
-        grid0.elon = tran
-    return

metradar/grid_data.py

@@ -1,64 +0,0 @@
-#!/usr/bin/python3.6
-# -*- coding:UTF-8 -*-
-import xarray as xr
-import numpy as np
-import pandas as pd
-
-
-#返回一个DataArray，其维度信息和grid描述一致，数组里面的值为0.
-def grid_data(grid,data=None):
-    slon = grid.slon
-    dlon = grid.dlon
-    slat = grid.slat
-    dlat = grid.dlat
-    nlon = grid.nlon
-    nlat = grid.nlat
-    # 通过起始经纬度和格距计算经纬度格点数
-    lon = np.arange(nlon) * dlon + slon
-    lat = np.arange(nlat) * dlat + slat
-    dt_str = grid.gtime[2]
-    if dt_str.find("m")>=0:
-        dt_str = dt_str.replace("m","min")
-
-    times = pd.date_range(grid.stime, grid.etime, freq=dt_str)
-    #print(times)
-    ntime = len(times)
-    # 根据timedelta的格式，算出ndt次数和gds时效列表
-
-    ndt = len(grid.dtimes)
-    gdt_list = grid.dtimes
-
-    level_list = grid.levels
-    nlevel_list = len(level_list)
-
-    member_list = grid.members
-    nmember = len(member_list)
-    if data is None:
-        data = np.zeros((nmember, nlevel_list, ntime, ndt, nlat, nlon))
-    else:
-        data = data.reshape(nmember, nlevel_list, ntime, ndt, nlat, nlon)
-
-    grd = (xr.DataArray(data, coords={'member': member_list,'level': level_list,'time': times,'dtime':gdt_list,
-                               'lat': lat, 'lon': lon},
-                         dims=['member', 'level','time', 'dtime','lat', 'lon']))
-
-    grd.name = "data0"
-    return grd
-
-
-def reset(grd):
-    lats = grd["lat"].values
-    if lats[0]>lats[1]:
-        lats = grd["lat"].values[::-1]
-        grd['lat'] = lats
-        dat = grd.values[:, :, :, :, ::-1, :]
-        grd.values = dat
-
-    lons = grd["lon"].values
-    if lons[0]>lons[1]:
-        lons = grd["lon"].values[::-1]
-        grd['lon'] = lons
-        dat = grd.values[:, :, :, :, :, ::-1]
-        grd.values = dat
-
-    return

metradar/oa_couhua.py

@@ -1,166 +0,0 @@
-'''
-封装凑华的客观分析程序
-2023年4月6日
-朱文剑
-
-'''
-
-# %%
-import numpy as np
-import math
-import time
-from grid import *
-from grid_data import *
-
-# %%迭代函数
-def frprmn2(x,targe,grads,tol = 0.001,caculate_time = 60,show = False):
-    x0 = x
-    n = len(x0)
-    x_min = math.sqrt(1.0/n)
-    df = grads(x0)
-    g_0 = -df
-    h_0 = g_0
-    f_min_line0 = 0
-    f_min_line1 = targe(x0)
-    start_time = time.time()
-    for i in range(10000):
-        d0 = np.dot(df,h_0)
-        x1 = x0 + h_0 * x_min
-        df = grads(x1)
-        d1 = np.dot(df,h_0)
-        if d0 == d1:
-            f_min_line1 = targe(x0)
-            return x0
-        else:
-            x_min = x_min * d0/(d0 - d1)
-            x0 += h_0 * x_min
-        df = grads(x0)
-        g_1 = -df
-        v1 = np.dot(g_1 - g_0, g_1)
-        v2 = np.dot(g_0,g_0)
-        h_0 = g_1 + (v1/v2) * h_0
-        g_0 = g_1
-        if i%10 == 0:
-            f_min_line0 = f_min_line1
-            f_min_line1 = targe(x0)
-            if show:print(str(i) + "  " + str(f_min_line1))
-            delta = 2 * abs(f_min_line1 - f_min_line0) / (abs(f_min_line1) + abs(f_min_line0)) - tol
-            if delta < 0:
-                return x0
-        if(time.time() - start_time > caculate_time):
-            return x0
-    print('迭代分析超过10000次而退出')
-    return x0
-
-# 客观分析算法的代码
-# def interp_sg_oa(sta0,background,sm = 1,effectR = 1000,rate_of_model = 0,show = False):
-def interp_sg_oa(x,y,z,reso,boundary=None,sm = 1,effectR = 1000,rate_of_model = 0,show = False):
-
-    if boundary is None:
-        wlon = int(np.min(x))
-        elon = int(np.max(x))+1
-        slat = int(np.min(y))
-        nlat = int(np.max(y))+1
-    else:
-        wlon = boundary[0]
-        elon = boundary[1]
-        slat = boundary[2]
-        nlat = boundary[3]
-
-    grid0 = grid([wlon,elon,reso],[slat,nlat,reso])
-    background = grid_data(grid0)
-    grd = background.copy()
-    ig = ((x - grid0.slon) // grid0.dlon).astype(dtype = 'int16')
-    jg = ((y - grid0.slat) // grid0.dlat).astype(dtype = 'int16')
-    dx = (x - grid0.slon) / grid0.dlon - ig
-    dy = (y - grid0.slat) / grid0.dlat - jg
-
-    # zhuwj add
-    flag1 = ig+1 <= grid0.nlon-1
-    flag2 = jg+1 <= grid0.nlat-1
-    flag = flag1 & flag2
-    ig = ig[flag]
-    jg = jg[flag]
-    dx = dx[flag]
-    dy = dy[flag]
-    z = z[flag]
-
-    c00 = (1 - dx) * (1 - dy)
-    c01 = dx * (1 - dy)
-    c10 = (1-dx) * dy
-    c11 = dx * dy
-    lat = grd["lat"].values
-    sr = 1/np.power(np.cos(lat*math.pi/180),4)
-    
-    
-
-    def targe(x):
-        grdv =  x.reshape(grid0.nlat,grid0.nlon)
-        dx = grdv[:,:-2] + grdv[:,2:] - 2 * grdv[:,1:-1]
-        dx2 = dx**2
-        sum_dx =np.sum(dx2,axis=1)
-        cost1 = np.sum(sum_dx * sr)
-
-        dy = grdv[:-2,:] + grdv[2:,:] - 2 * grdv[1:-1,:]
-        dy2 = dy**2
-        sum_dy = np.sum(dy2)
-        cost1 = cost1 + sum_dy
-       
-        sta_g = c00 * grdv[jg, ig] + c01 * grdv[jg, ig + 1] + c10 * grdv[jg + 1, ig] + c11 * grdv[
-            jg + 1, ig + 1]
-        error = z - sta_g
-        cost2 = np.sum(error**2)
-        cost3 = 0
-        cost = sm * cost1 + cost2 + cost3
-        return cost
-
-    def grads(x):
-        grdv = x.reshape(grid0.nlat,grid0.nlon)
-        g1 = np.zeros(grdv.shape)
-
-        sr_expend = np.tile(sr,[grid0.nlon-2,1]).T
-
-        dx = 2 * (grdv[:,:-2] + grdv[:,2:] - 2 * grdv[:,1:-1])
-        dx_sr = dx * sr_expend
-        g1[:,:-2] = dx_sr
-        g1[:,2:] += dx_sr
-        g1[:,1:-1] -= 2*dx_sr
-
-        dy = 2 *(grdv[:-2,:] + grdv[2:,:] - 2 * grdv[1:-1,:])
-        g1[:-2,:] += dy
-        g1[2:,:] += dy
-        g1[1:-1,:] -= 2 * dy
-
-        g2 = np.zeros(grdv.shape)
-        sta_g = c00 * grdv[jg, ig] + c01 * grdv[jg, ig + 1] + c10 * grdv[jg + 1, ig] + c11 * grdv[jg + 1, ig + 1]
-        d = 2 * (sta_g - z)
-        g2[jg,ig] += d * c00
-        g2[jg,ig + 1]  += d * c01
-        g2[jg+1,ig] += d * c10
-        g2[jg+1,ig+1] += d * c11
-
-        g3 = 0
-        
-        g = sm * g1 + g2 + g3
-        return g.reshape(-1)
-
-    x = grd.values.reshape(-1)
-    x_oa = frprmn2(x, targe, grads,show  = show)
-    result = grid_data(grid0,x_oa)
-
-    grid_x = np.linspace(wlon, elon, grid0.nlon)
-    grid_y = np.linspace(slat, nlat, grid0.nlat)
-
-    gx, gy = np.meshgrid(grid_x, grid_y)
-
-    return gx, gy,result.data[0,0,0,0,:,:]
-    
-    # return result
-
-
-# %%
-
-if __name__ == "__main__":
-    #读取观测数据
-    pass
-

metradar/read_new_mosaic.py

@@ -1,33 +0,0 @@
-'''
-读取新的雷达拼图数据
-
-'''
-from read_new_mosaic_func import decode_mosaic
-from draw_mosaic_new import draw_mosaic
-
-if __name__ == '__main__':
-	# filepath = '/Users/wenjianzhu/Downloads/CMADAAS/rdmosaic_bin/202208/'1
-	# filepath = '/Users/wenjianzhu/Library/CloudStorage/OneDrive-个人/推广应用/GR2/四川/测试数据/雷达拼图'
-	filepath = 'testdata/national_mosaic'
-	# filename = 'Z_RADA_C_BABJ_20220826001200_P_DOR_ACHN_QREF_20220826_001821.bin'
-	filename = 'ACHN_CREF_20210918_155000.BIN'
-	outpath = 'pic'
-	outname = filename + '.png'
-	data = decode_mosaic(filepath,filename)
-
-	pass
-	slat = 15.0
-	nlat = 56
-	wlon = 70.
-	elon = 140.
-	# newdata = data.CREF.sel(lat=slice(slat,nlat),lon=slice(wlon,elon))
-	# tstr = filename.split('_')[4]
-	# draw_mosaic(newdata.data,newdata.lat.data,newdata.lon.data,slat,nlat,wlon,elon,outpath,outname,tstr,thred=15,dpi=800)
-
-
-	newdata = data.CREF.sel(lat=slice(slat,nlat),lon=slice(wlon,elon))
-	tstr = filename.split('_')[2]+'_'+filename.split('_')[3]
-	draw_mosaic(newdata.data,newdata.lat.data,newdata.lon.data,slat,nlat,wlon,elon,outpath,outname,tstr,add_title=1,
-			 prefix_title='雷达组合反射率拼图',units='dBZ',thred=0,dpi=800)
-
-# %%