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

metradar/{make_mosaic_mp_archive.py → project/make_mosaic/make_mosaic_func.py}

@@ -1,11 +1,7 @@
-'''
-制作雷达拼图，多进程
-朱文剑
-2021
+# _*_ coding: utf-8 _*_
 
-'''
+# 制作三维拼图的核心函数
 
-# %%
 
 import pyart
 import os
@@ -13,15 +9,23 @@ import time
 import pandas as pd
 from datetime import datetime,timedelta
 import numpy as np
-from multiprocessing import Process,Pool
-from mosaic_merge import mosaic_merge
+from multiprocessing import Pool
+from metradar.core.mosaic_merge import mosaic_merge
+
 import configparser
 import warnings
 import glob
 warnings.filterwarnings('ignore')
-import schedule
-import threading
-from decode_fmt_pyart import read_cnrad_fmt
+
+from metradar.util.radar_common import RADAR_COMMON
+from metradar.io.decode_fmt_pyart import read_cnrad_fmt
+radarcommon = RADAR_COMMON()
+
+from metradar.config import CONFIG
+
+# 资源文件路径
+RESOURCES_PATH = CONFIG.get('SETTING','RESOURCES_PATH')
+RADAR_FILE = RESOURCES_PATH + '/stations/radars.csv'
 
 class MAKE_RADAR_MOSAIC:
 
@@ -49,25 +53,29 @@ class MAKE_RADAR_MOSAIC:
 
         return config
         
-    def __init__(self,rcfile) -> None:
+    def __init__(self,rcfile):
         self.berror = False
         if not os.path.exists(rcfile):
             print(rcfile + ' not exists!')
             self.berror = True
-            return None
+            
+
         config = self._get_config_from_rcfile(rcfile)
         self.run_mode = config['RUN_MODE']['run_mode']
+        
 
         self.radar_mode = config['COMMON_SETTING']['radar_mode']
-        self.radar_sitesfile = config['COMMON_SETTING']['radar_sitesfile']
+        self.radar_sitesfile = RADAR_FILE
 
         if not os.path.exists(self.radar_sitesfile):
-            print(self.radar_sitesfile + ' not exists!')
+            print("雷达站点文件：" + self.radar_sitesfile + ' 不存在，请检查!')
             self.berror = True
-            return None
+            
 
         self.realtime_peroids = int(config['REAL_TIME']['realtime_peroids'])
 
+        self.filename_type = config['COMMON_SETTING']['filename_type']
+        
         self.center_lon = float(config['COMMON_SETTING']['center_lon'])
         self.center_lat = float(config['COMMON_SETTING']['center_lat'])
         self.mosaic_range = float(config['COMMON_SETTING']['mosaic_range'])
@@ -85,9 +93,8 @@ class MAKE_RADAR_MOSAIC:
             self.radars = config['COMMON_SETTING']['radars'].split(',')
             self.radars = [tt.strip(' ') for tt in self.radars]
         else:
-            pass
-            # 根据经纬度和半径，自动计算目标范围内的雷达站名
-            # 将km半径大致除以100，换算成°
+            # Automatically calculate the radar station name within the target range according to longitude, latitude and radius
+            #
             minlon = self.center_lon - self.mosaic_range / 100.0
             maxlon = self.center_lon + self.mosaic_range / 100.0
             minlat = self.center_lat - self.mosaic_range / 100.0
@@ -95,12 +102,11 @@ class MAKE_RADAR_MOSAIC:
 
             # load radar site file
 
-            # 根据数字站号查找对应的中文名
+            # Find the corresponding Chinese name according to the digital station number
             
             frad = open(self.radar_sitesfile,'rt',encoding='UTF-8')
             
             infos = frad.readlines()
-            radsite_num = {}
             radname_gr2 = {}
             staname_chn={}
             radarlat={}
@@ -113,13 +119,13 @@ class MAKE_RADAR_MOSAIC:
                 curlon = float(tmps[4])
                 curlat = float(tmps[3])
                 if curlon > minlon and curlon < maxlon and curlat > minlat and curlat < maxlat:
-                    radsite_num[tmps[0]] = tmps[2]
+
                     radname_gr2[tmps[2]] = tmps[0]
                     staname_chn[tmps[2]] = tmps[1]
                     radarlat[tmps[2]]=float(tmps[3])
                     radarlon[tmps[2]]=float(tmps[4])
                     radheight[tmps[2]]=float(tmps[5])
-            self.radars = list(radsite_num.keys())
+            self.radars = list(staname_chn.values())
 
         self.input_path_realtime = config['REAL_TIME']['input_path_realtime']
         self.output_path_realtime = config['REAL_TIME']['output_path_realtime']
@@ -136,56 +142,31 @@ class MAKE_RADAR_MOSAIC:
         except:
             self.berror = True
             print('starttime set error!')
-            return None
+ 
         
         try:
             et = datetime.strptime(self.endtime,'%Y%m%d%H%M')
         except:
             self.berror = True
             print('endtime set error!')
-            return None
 
-        
 
         # check time step
         if self.tstep < 0 or self.tstep > 60:
             print('tstep set error, should between 0 and 60')
             self.berror = True
-            return None
+
         
         if (et - st).total_seconds() < self.tstep * 60:
             print('seconds between endtime and starttime is less than tstep, error!')
             self.berror = True
-            return None
-
 
-        pass
+        if self.berror:
+            return radarcommon.RETURN_CODE_PARAM_ERROR
 
 
     def make_mosaic(self, params):
     
-        '''
-        params={
-            # 原始数据路径
-            'rootpath':rootpath,
-            # 输出数据路径
-            'outpath': outpath,
-            # 参与拼图的雷达站点
-            'radars': ['NJJS','HAJS','BBAH','MASR','HFAH','CZJS','TZJS'], 
-            'origin_latitude':center_lat, # 拼图的中心纬度
-            'origin_longitude':center_lon, # 拼图的中心经度
-            'mosaic_range':mosaic_range, # 拼图半径，km，其实是正方形
-            'hor_reso':1, # 水平方向分辨率，km
-            'ver_reso':0.5, # 垂直方向分辨率，km
-            'bdebug':True,
-            'timestr':timestr,
-            'bot_z_lev':0.5, # 最底层所在高度
-            'top_z_lev':16,  # 最顶层所在高度
-            'breplace':True, 
-            'outname': 'mosaic_%s.nc'%timestr
-            }
-        '''
-
         rootpath=params['rootpath']
         outpath=params['outpath']
         radars=params['radars']
@@ -201,51 +182,39 @@ class MAKE_RADAR_MOSAIC:
         top_z_lev = params['top_z_lev']
         breplace = params['breplace']
 
-        # if timestr == '202307031912':
-        #     pass
-        if not os.path.exists(outpath): os.makedirs(outpath)
-        # timestr = '201607190112'
+
+        os.makedirs(outpath,exist_ok=True)
+        # timestr = '20220415155500'
         if not breplace and os.path.exists(outpath + os.sep + outname): 
             print(outname + ' already exits!')
             return False
-        curt = datetime.strptime(timestr,'%Y%m%d%H%M')
+        curt = datetime.strptime(timestr,'%Y%m%d%H%M%S') 
         curt = curt.timestamp()
         timeinfo=dict()
         fileinfo=dict()
         nvalidradars = 0
         validradars=[]
+        
+        # 遍历所有目录
+       
         for radar in radars:
-            curpath = rootpath  + os.sep + radar
-            if not os.path.exists(curpath):
-                # print(curpath + ' not exists!')
-                # radars.remove(radar)
-                continue
-            
-            curfiles = os.listdir(curpath)
-            if len(curfiles)==0:
-                print(curpath + ' file number = %d'%len(curfiles))
-                continue
             
             validfiles = []
-            for ff in curfiles:
-                # if ff.find('ar2v') < 0:
-                if ff.find('_CAP_FMT.bin.bz2') < 0:
-                    continue
-                else:
-                    validfiles.append(ff)
+            validpaths = []
+            for root, dirs, files in os.walk(rootpath):
+                for file in files:
+                    if file.endswith('.bz2'):
+                        if file.find(radar) < 0:
+                            continue
+                        validfiles.append(file)
+                        validpaths.append(root)
+            
             curfiles = sorted(validfiles)
             tmptime=[]
             tmpfile=[]
             for file in curfiles:
-                if file.find(radar) < 0:
-                    print(file + ' not contain  %s, so continue...'%radar)
-                    # curfiles.remove(file)
-                    continue
-
-                # cft = datetime.strptime(file[5:5+14],'%Y%m%d%H%M%S')
-                # Z_RADR_I_Z9090_20230703193348_O_DOR_SB_CAP_FMT.bin.bz2
-                # cft = datetime.strptime(file[5:13]+file[14:20],'%Y%m%d%H%M%S')
-                cft = datetime.strptime(file[15:29],'%Y%m%d%H%M%S')
+                curpath = validpaths[validfiles.index(file)]
+                cft = datetime.strptime(file.split('_')[4],'%Y%m%d%H%M%S')
                 tmptime.append(cft.timestamp())
                 tmpfile.append(curpath + os.sep + file)
             if len(tmptime)==0:
@@ -256,6 +225,7 @@ class MAKE_RADAR_MOSAIC:
 
             nvalidradars +=1
             validradars.append(radar)
+
         used_files = []
         if nvalidradars == 0:
             print('no valid files')
@@ -272,16 +242,19 @@ class MAKE_RADAR_MOSAIC:
                 idx = idx[0]
             if abs(tmpt[idx]) > 240:
                 continue
+
             used_files.append(fileinfo[radar][idx])
         # assert isinstance(filenames,list)
 
         if len(used_files)==0:
             print('Error: len(used_files)==0')
-            return False
+            return radarcommon.RETURN_CODE_DATA_ERROR
+
         xgridnum = int(2*mr/hor_reso) + 1
         ygridnum = int(2*mr/hor_reso) + 1
         zgridnum = int((top_z_lev - bot_z_lev)/ver_reso) + 1
-        print('xgridnum = %d, ygridnum = %d, zgridnum = %d'%(xgridnum,ygridnum,zgridnum))
+        print('top_z_lev = %.1f, bot_z_lev = %.1f, xgridnum = %d, ygridnum = %d, zgridnum = %d'%(top_z_lev,bot_z_lev,xgridnum,ygridnum,zgridnum))
+        
         radars=[]
         for filename in used_files:
             try:
@@ -291,7 +264,7 @@ class MAKE_RADAR_MOSAIC:
                 print(filename + ' read error!')
                 continue
             radars.append(radar) 
-            print('add file %s'%filename)
+            # print('add file %s'%filename)
 
         sttime = time.time()
         grid = pyart.map.grid_from_radars(
@@ -299,7 +272,7 @@ class MAKE_RADAR_MOSAIC:
             grid_origin = [origin_latitude,origin_longitude],
             grid_shape=(zgridnum, ygridnum, xgridnum),
             grid_limits=((bot_z_lev*1000, top_z_lev*1000), (-1.0*mr*1000, 1.0*mr*1000), (-1.0*mr*1000, 1.0*mr*1000)),
-            fields=['reflectivity',])#'differential_reflectivity','differential_phase'
+            fields=['reflectivity'])
             
         edtime = time.time()
         if bdebug:
@@ -322,7 +295,7 @@ class MAKE_RADAR_MOSAIC:
         # gx.reflectivity.data=gx.reflectivity.astype(np.uint8)
         # gx = gx.drop_vars('ROI')
         # cref = np.nanmax(gx.reflectivity.data[0,:,:,:],axis=0)
-        # # 增加变量到Dataset
+        # # add var to Dataset
         # gx["cref"]=(['y', 'x'],cref,{'scale':2,'offset':64,'decode':'dBZ = (cref-64)/2'})
         # # gx = gx.drop_vars('reflectivity')
         # gx.to_netcdf(outpath + os.sep + outname)
@@ -331,15 +304,32 @@ class MAKE_RADAR_MOSAIC:
 
         print(outpath + os.sep + outname + ' done!')
 
+        
+        return radarcommon.RETURN_CODE_SUCESSED
+
     def do_realtime(self,):
-        if os.path.exists('file.lock'): 
-            print('do_realtime still running')
-            return False
+        if os.path.exists('file_mosaic.lock'): 
+            # check time If more than 10 minutes have passed, delete and run
+            fin = open('file_mosaic.lock','rt')
+            tstr = fin.readline()
+            fin.close()
+            brestart = False
+            if len(tstr) == 0:
+                brestart = True
+            ctt = datetime.strptime(tstr,'%Y%m%d%H%M%S')
+            if datetime.utcnow().timestamp() -  ctt.timestamp() > 60*10:
+                brestart = True
+
+            if brestart:
+                os.remove('file_mosaic.lock')
+            else:
+                print('do_realtime is still running')
+                return radarcommon.RETURN_CODE_SUCESSED
 
-        print('进入 do_realtime')
+        print('entering do_realtime')
 
-        # 创建锁文件，防止程序重复运行
-        lockfile = open('file.lock','wt')
+        # Create a lock file to prevent the program from running repeatedly
+        lockfile = open('file_mosaic.lock','wt')
         lockfile.write(datetime.utcnow().strftime('%Y%m%d%H%M%S'))
         lockfile.close()
 
@@ -357,36 +347,34 @@ class MAKE_RADAR_MOSAIC:
 
         allparams = []
         ct = datetime.utcnow()
-        newct = ct - timedelta(minutes= ct.minute % 6 )
-        timestr = newct.strftime('%Y%m%d%H%M')
+        newct = ct - timedelta(minutes= (ct.minute % 6 + 6))
+        timestr = newct.strftime('%Y%m%d%H%M') + '00'
         print('processing : ' + timestr)
 
         alloutfiles=[]
-        mergename = outpath + os.sep +  'mosaic_%s.nc'%timestr
+        aa = self.filename_type.split('$')
+        mergename = outpath + os.sep +  '%s%s%s'%(aa[0],timestr,aa[2])
         if not breplace and os.path.exists(mergename):
             print(mergename + ' already exists!')
-            return True
+            return radarcommon.RETURN_CODE_SUCESSED
 
         for nn in range(len(levels)-1):
-
-            outname = 'mosaic_%s_%d_tmp.nc'%(timestr,nn+1)
-            # 分为多个进程，每个进程计算一段高度上的拼图，最后再进行拼接
+            # 'mosaic_%s_%d_tmp.nc'%(timestr,nn+1) 
+            outname = '%s%s_%d_tmp%s'%(aa[0],timestr,nn+1,aa[2])
+            # It is divided into multiple processes. Each process calculates a piece of puzzle on height, and then splices it
             params={
-            # 原始数据路径
-            'rootpath':rootpath,
-            # 输出数据路径
-            'outpath': outpath,
-            # 参与拼图的雷达站点
+            'rootpath':rootpath,  
+            'outpath': outpath, 
             'radars':radars, 
-            'origin_latitude':center_lat, # 拼图的中心纬度
-            'origin_longitude':center_lon, # 拼图的中心经度
-            'mosaic_range':mosaic_range, # 拼图半径，km，其实是正方形
-            'hor_reso':hor_reso, # 水平方向分辨率，km
-            'ver_reso':ver_reso, # 垂直方向分辨率，km
+            'origin_latitude':center_lat, 
+            'origin_longitude':center_lon, 
+            'mosaic_range':mosaic_range,
+            'hor_reso':hor_reso,
+            'ver_reso':ver_reso, 
             'bdebug':bshow_debug,
-            'timestr':timestr, # 时间戳，程序按照这个时间来匹配数据
-            'bot_z_lev':levels[nn] + ver_reso, # 最底层所在高度
-            'top_z_lev':levels[nn+1],  # 最顶层所在高度
+            'timestr':timestr, 
+            'bot_z_lev':levels[nn] + ver_reso, 
+            'top_z_lev':levels[nn+1], 
             'breplace':breplace, 
             'outname':outname,
             }
@@ -401,50 +389,53 @@ class MAKE_RADAR_MOSAIC:
         pools.close()
         pools.join()
 
-        # 对数据进行拼接
+        # merge data
         
         newgrid = mosaic_merge(files = alloutfiles)
         # write to file
         if newgrid is not None:
             newgrid.write(mergename)
             print(mergename + ' saved!')
-                # time.sleep(2)
             
+
         else:
             print('merge error!')
+
         # delete temp files
         files = glob.glob(outpath + os.sep + '*tmp.nc')
         if len(files) >0:
             for file in files:
                 os.remove(file)   
         
-        # 删除锁文件，允许程序运行
-        if os.path.exists('file.lock'): os.remove('file.lock')
+        # Delete the lock file and allow the program to run
+        if os.path.exists('file_mosaic.lock'): os.remove('file_mosaic.lock')
 
+        
 
     def do_archive(self,):
 
         st = datetime.strptime(self.starttime,'%Y%m%d%H%M')
         et = datetime.strptime(self.endtime,'%Y%m%d%H%M')
-        periods = int(((et - st).total_seconds() / 60)/self.tstep)+1
+        periods = int(((et - st).total_seconds() / 60)/self.tstep)
         print('periods = %d'%periods)
         dt = pd.date_range(st,freq='%dmin'%self.tstep,periods=periods)
         dt = pd.to_datetime(dt)
         alltimes=[tt.strftime('%Y%m%d%H%M') for tt in dt]
 
-        
-            
-        # radars = self.radars
-        # center_lat = _make_mosaic.center_lat
-        # center_lon = _make_mosaic.center_lon
-        # mosaic_range = _make_mosaic.mosaic_range
-        # hor_reso = _make_mosaic.hori_reso
-        # ver_reso = _make_mosaic.verti_reso
-        # bshow_debug = self.bshow_debuginfo
-        # breplace = _make_mosaic.breplace
-        # levels = self.multi_levels
-
-        # levels  高度层 单位KM
+        rootpath = self.input_path_archive
+        outpath = self.output_path_archive
+
+        radars = self.radars
+        center_lat = self.center_lat
+        center_lon = self.center_lon
+        mosaic_range = self.mosaic_range
+        hor_reso = self.hori_reso
+        ver_reso = self.verti_reso
+        bshow_debug = self.bshow_debuginfo
+        breplace = self.breplace
+        levels = self.multi_levels
+
+        # levels  KM
         # levels = [0, 5, 9, 12, 16]
         # levels = [0, 7, 10, 13, 16, 20] 82s
         # levels = [0, 7, 10, 13, 16, 20]
@@ -456,51 +447,46 @@ class MAKE_RADAR_MOSAIC:
             print('processing : ' + timestr)
 
             alloutfiles=[]
-            rootpath = self.input_path_archive + os.sep + timestr[0:4] + os.sep + timestr[0:8]
-            outpath = self.output_path_archive
-
-            if not os.path.exists(outpath):
-                os.makedirs(outpath)
             mergename = outpath + os.sep +  'mosaic_%s.nc'%timestr
-            if not self.breplace and os.path.exists(mergename):
+            if not breplace and os.path.exists(mergename):
                 print(mergename + ' already exists!')
                 continue
 
-            for nn in range(len(self.multi_levels)-1):
+            for nn in range(len(levels)-1):
 
                 outname = 'mosaic_%s_%d_tmp.nc'%(timestr,nn+1)
-                # 分为多个进程，每个进程计算一段高度上的拼图，最后再进行拼接
+                
                 params={
-                # 原始数据路径
+                
                 'rootpath':rootpath,
-                # 输出数据路径
+               
                 'outpath': outpath,
-                # 参与拼图的雷达站点
-                'radars':self.radars, 
-                'origin_latitude':self.center_lat, # 拼图的中心纬度
-                'origin_longitude':self.center_lon, # 拼图的中心经度
-                'mosaic_range':self.mosaic_range, # 拼图半径，km，其实是正方形
-                'hor_reso':self.hori_reso, # 水平方向分辨率，km
-                'ver_reso':self.verti_reso, # 垂直方向分辨率，km
-                'bdebug':self.bshow_debuginfo,
-                'timestr':timestr, # 时间戳，程序按照这个时间来匹配数据
-                'bot_z_lev':self.multi_levels[nn] + nn*self.verti_reso, # 最底层所在高度
-                'top_z_lev':self.multi_levels[nn+1],  # 最顶层所在高度
-                'breplace':self.breplace, 
+                
+                'radars':radars, 
+                'origin_latitude':center_lat,
+                'origin_longitude':center_lon, 
+                'mosaic_range':mosaic_range, 
+                'hor_reso':hor_reso, 
+                'ver_reso':ver_reso, 
+                'bdebug':bshow_debug,
+                'timestr':timestr, 
+                'bot_z_lev':levels[nn] + ver_reso, 
+                'top_z_lev':levels[nn+1], 
+                'breplace':breplace, 
                 'outname':outname,
                 }
 
                 alloutfiles.append(outpath + os.sep + outname)
                 allparams.append(params)
 
-            MAXP=len(self.multi_levels)-1
+            MAXP=len(levels)-1
             pools = Pool(MAXP)
 
             pools.map(self.make_mosaic, allparams)
             pools.close()
             pools.join()
 
-            # 对数据进行拼接
+            # merge data
             
             newgrid = mosaic_merge(files = alloutfiles)
             if newgrid is not None:
@@ -516,23 +502,6 @@ class MAKE_RADAR_MOSAIC:
             if len(files) >0:
                 for file in files:
                     os.remove(file)
-
-def run_threaded(job_func):
-    job_thread = threading.Thread(target=job_func)
-    job_thread.start()
-
-if __name__ == "__main__":
-
-    print('starting mosaic program......')
-    
-    _make_mosaic = MAKE_RADAR_MOSAIC('make_mosaic_mp_archive.ini')
-
-    if not _make_mosaic.berror:
-        if _make_mosaic.run_mode == 'archive':
-            _make_mosaic.do_archive()
-        else:
-            print('run mode is not archive!')
-
-            
-
-# %%
+        
+        
+        return radarcommon.RETURN_CODE_SUCESSED

metradar/project/make_mosaic/make_mosaic_mp.ini

@@ -0,0 +1,29 @@
+[RUN_MODE]
+run_mode = archive
+
+[REAL_TIME]
+input_path_realtime = X:/radar/Archives
+output_path_realtime = E:/metradar_test/realtime_mosaic
+realtime_peroids = 3
+
+[ARCHIVE]
+input_path_archive = /mnt/e/metradar_test/vpr/FMT
+output_path_archive = /mnt/e/metradar_test/vpr/mosaic/20230731_daxing
+starttime = 202307310700
+endtime = 202307311200
+tstep = 6
+
+[COMMON_SETTING]
+filename_type = Z_RADR_TDMOSAIC_$YYYYMMDDhhmmss$.nc
+radar_mode = manul
+radars = Z9010,Z9220,Z9311,Z9317,Z9024,Z9025,
+center_lon = 116.347
+center_lat = 39.458
+mosaic_range = 50
+hori_reso = 1.0
+verti_reso = 0.5
+multi_levels = 0, 3,6, 9, 12, 15, 18, 20
+mosaic_vars = REF,ZDR
+breplace = 0
+bshow_debuginfo = 1
+

metradar/project/make_mosaic/make_mosaic_mp.py

@@ -0,0 +1,70 @@
+# _*_ coding: utf-8 _*_
+
+
+'''
+make radarmosaic
+wenjianzhu
+
+
+'''
+
+# %%
+import os
+from datetime import datetime,timedelta
+import glob
+import schedule
+import time
+import threading
+from metradar.project.make_mosaic.make_mosaic_func import MAKE_RADAR_MOSAIC
+
+
+def run_threaded(job_func):
+    job_thread = threading.Thread(target=job_func)
+    job_thread.start()
+
+if __name__ == "__main__":
+
+    print('starting mosaic program......')
+    with open('current_pid_mosaic.txt','wt') as f:
+        f.write('当前进程号为: %s'%str(os.getpid()) + '  ,' + datetime.now().strftime('%Y-%m-%dT%H:%M:%S'))
+
+    # 路径需要根据实际情况进行修改
+    _make_mosaic = MAKE_RADAR_MOSAIC('/home/wjzhu/OneDrive/PythonCode/MyWork/metradar/metradar/project/make_mosaic/make_mosaic_mp.ini')
+
+    if not _make_mosaic.berror:
+
+        if _make_mosaic.run_mode == 'realtime':
+            # Delete the lock file and allow the program to run
+            if os.path.exists('file_mosaic.lock'): os.remove('file_mosaic.lock')
+            
+            if not os.path.exists(_make_mosaic.output_path_realtime):
+                os.makedirs(_make_mosaic.output_path_realtime)
+
+            if not os.path.exists(_make_mosaic.output_path_archive):
+                os.makedirs(_make_mosaic.output_path_archive)
+
+            # delete tmp.nc
+            # delete temp files
+            files = glob.glob(_make_mosaic.output_path_realtime + os.sep + '*tmp.nc')
+            if len(files) >0:
+                for file in files:
+                    os.remove(file)   
+
+            files = glob.glob(_make_mosaic.output_path_archive + os.sep + '*tmp.nc')
+            if len(files) >0:
+                for file in files:
+                    os.remove(file) 
+
+            # create task
+            run_threaded(_make_mosaic.do_realtime)
+            schedule.every(_make_mosaic.realtime_peroids*60).seconds.do(run_threaded, _make_mosaic.do_realtime)
+            while True:
+                schedule.run_pending()
+                time.sleep(1)
+             
+        else: # archive mode
+            _make_mosaic.do_archive()
+            
+
+# %%
+

metradar/project/make_vpr_aws/__init__.py

@@ -0,0 +1,9 @@
+"""
+metradar is a python package to read or retrieve radar data
+
+"""
+
+__author__ = "The R & D Center for Weather Forecasting Technology in NMC, CMA"
+
+
+__all__ = [s for s in dir() if not s.startswith('_')]