def bath(self, **kwargs):
kwargs["grid_x"] = self.grid.Dataset.lons.values
kwargs["grid_y"] = self.grid.Dataset.lats.values
dpath = get_value(self, kwargs, "dem", None)
kwargs.update({"dem": dpath})
flag = get_value(self, kwargs, "update", [])
# check if files exist
if flag:
if ("dem" in flag) | ("all" in flag):
kwargs.update({
"lon_min": self.lon_min,
"lat_min": self.lat_min,
"lon_max": self.lon_max,
"lat_max": self.lat_max,
})
self.dem = pdem.dem(**kwargs)
else:
logger.info("reading local dem file ..\n")
dem_source = z["rpath"] + self.tag + ".dep"
rdem = from_dep(dem_source)
else:
kwargs.update({
"lon_min": self.lon_min,
"lat_min": self.lat_min,
"lon_max": self.lon_max,
"lat_max": self.lat_max
})
self.dem = pdem.dem(**kwargs)
def bath(self, **kwargs):
kwargs['grid_x'] = self.grid.Dataset.lons.values
kwargs['grid_y'] = self.grid.Dataset.lats.values
dpath = get_value(self, kwargs, 'dem', None)
kwargs.update({'dem': dpath})
flag = get_value(self, kwargs, 'update', [])
# check if files exist
if flag:
if ('dem' in flag) | ('all' in flag):
kwargs.update({
'lon_min': self.lon_min,
'lat_min': self.lat_min,
'lon_max': self.lon_max,
'lat_max': self.lat_max
})
self.dem = pdem.dem(**kwargs)
else:
logger.info('reading local dem file ..\n')
dem_source = z['rpath'] + self.tag + '.dep'
rdem = from_dep(dem_source)
else:
kwargs.update({
'lon_min': self.lon_min,
'lat_min': self.lat_min,
'lon_max': self.lon_max,
'lat_max': self.lat_max
})
self.dem = pdem.dem(**kwargs)
def d3d(tmpdir, kwargs):
## lat,lon grid
resolution = 0.1
lon = np.arange(kwargs["lon_min"], kwargs["lon_max"], resolution)
lat = np.arange(kwargs["lat_min"], kwargs["lat_max"], resolution)
xp, yp = np.meshgrid(lon, lat)
kwargs.update({"grid_x": xp, "grid_y": yp})
# get dem
df = pdem.dem(**kwargs)
rpath = str(tmpdir) + "/"
# output
pdem.to_output(df.Dataset, solver="d3d", rpath=rpath)
# read again dem
m = pmodel(solver="d3d")
rd = m.from_dep(rpath + "d3d.dep")
# compare
c1 = -rd.where(rd != -999)
c2 = df.Dataset.ival.where(df.Dataset.ival < 0)
return c1.fillna(0).equals(c2.fillna(0))
def test_d3d_grid(tmpdir, natural_earth, dem_source, window):
grid = pg.grid(type="r2d", geometry=window, resolution=0.1, rpath=str(tmpdir) + "/")
gr = grid.Dataset
xp, yp = gr.lons, gr.lats
df = pdem.dem(**window, grid_x=xp, grid_y=yp, dem_source=dem_source)
df.adjust(natural_earth)
assert np.isnan(df.Dataset.fval.values).sum() == 0
def test_schism_grid(tmpdir, natural_earth, dem_source, window):
grid = pg.grid(type="tri2d", geometry=window, coastlines=natural_earth, rpath=str(tmpdir) + "/")
xg = grid.Dataset.SCHISM_hgrid_node_x.values
yg = grid.Dataset.SCHISM_hgrid_node_y.values
df = pdem.dem(**window, grid_x=xg, grid_y=yg, dem_source=dem_source) # get dem
df.adjust(natural_earth)
assert np.isnan(df.Dataset.fval.values).sum() == 0
def d3d(tmpdir, kwargs):
## lat,lon grid
resolution = .1
lon = np.arange(kwargs['lon_min'], kwargs['lon_max'], resolution)
lat = np.arange(kwargs['lat_min'], kwargs['lat_max'], resolution)
xp, yp = np.meshgrid(lon, lat)
kwargs.update({'grid_x': xp, 'grid_y': yp})
#get dem
df = pdem.dem(**kwargs)
rpath = str(tmpdir) + '/'
#output
pdem.to_output(df.Dataset, solver='d3d', rpath=rpath)
#read again dem
m = pmodel(solver='d3d')
rd = m.from_dep(rpath + 'd3d.dep')
#compare
c1 = -rd.where(rd != -999)
c2 = df.Dataset.ival.where(df.Dataset.ival < 0)
return c1.fillna(0).equals(c2.fillna(0))
def schism(tmpdir, kwargs):
grid = pgrid.grid(type='tri2d',
grid_file=(DATA_DIR / 'hgrid.gr3').as_posix())
#update dem
xp = grid.Dataset.SCHISM_hgrid_node_x.values
yp = grid.Dataset.SCHISM_hgrid_node_y.values
kwargs.update({'grid_x': xp, 'grid_y': yp})
#get dem
df = pdem.dem(**kwargs)
grid.Dataset['depth'].loc[:] = -df.Dataset.ival.values
filename_ = str(tmpdir.join('hgrid_.gr3'))
#output to grid file
grid.to_file(filename_)
#read again new grid
grid_ = pgrid.grid(type='tri2d', grid_file=filename_)
#compare
return grid.Dataset.equals(grid_.Dataset)
def test_d3d_grid(tmpdir, dic):
grid = pg.grid(type="r2d",
geometry=dic,
resolution=0.1,
rpath=str(tmpdir) + "/")
gr = grid.Dataset
xp, yp = gr.lons, gr.lats
# get dem
df = pdem.dem(**dic, grid_x=xp, grid_y=yp, dem_source=DEM_SOURCE)
df.adjust(natural_earth)
assert np.isnan(df.Dataset.fval.values).sum() == 0
def make_gmsh(df, **kwargs):
logger.info('create grid')
model = gmsh.model
factory = model.geo
gmsh.initialize()
model.add("schism")
# gmsh.option.setNumber("General.Terminal", 1)
interpolate = kwargs.get('interpolate', False)
if interpolate:
ddf=gset(df,**kwargs)
else:
ddf=df
lc = kwargs.get('lc', .5)
ddf['lc'] = lc
ddf = ddf.apply(pd.to_numeric)
# save boundary configuration for Line0
rb0=ddf.loc['line0'].copy()
if not shapely.geometry.LinearRing(rb0[['lon','lat']].values).is_ccw:# check for clockwise orientation
rb0=ddf.loc['line0'].iloc[::-1].reset_index(drop=True)
rb0.index=rb0.index+1 # fix index
rb0['bounds']=[[i,i+1] for i in rb0.index]
rb0['bounds']=rb0.bounds.values.tolist()[:-1]+[[rb0.index[-1],1]] # fix last one
#store blines
blines={}
for tag_ in rb0.tag.unique():
ibs=rb0.loc[rb0.tag==tag_].index.values
#ibs
lbs=rb0.loc[rb0.tag==tag_].bounds.values.tolist()
#lbs
ai=np.unique(np.concatenate(lbs))
#ai
itags=[i for i in ai if i in ibs]
#itags
if tag_ > 0:
items = set(itags)
imask=[set(x).issubset(items) for x in rb0.loc[rb0.tag==tag_].bounds]
#imask
bi=rb0.loc[rb0.tag==tag_][imask].index.values.tolist()
else:
bi=rb0.loc[rb0.tag==tag_].index.values.tolist()
blines.update({tag_:bi})
al = [j for i in list(blines.values()) for j in i]
lover=[x for x in rb0.index if x not in al]
for i,v in rb0.loc[lover].iterrows():
nns=rb0.loc[v[5],['tag']].values
itag=[x for x in nns if x < 0 ][0]
blines.update({itag[0]:blines[itag[0]]+[i]})
land_lines = { your_key: blines[your_key] for your_key in [x for x in blines.keys() if x < 0] }
open_lines = { your_key: blines[your_key] for your_key in [x for x in blines.keys() if x > 0] }
logger.info('Define geometry')
loops=[]
islands=[]
all_lines=[]
ltag=1
for row in rb0.itertuples(index=True, name='Pandas'):
factory.addPoint(getattr(row, "lon"),getattr(row, "lat"),getattr(row, "z"),getattr(row, "lc"),getattr(row, "Index"))
for row in rb0.itertuples(index=True, name='Pandas'):
factory.addLine(getattr(row, "bounds")[0],getattr(row, "bounds")[1],getattr(row, "Index"))
lines=rb0.index.values
all_lines.append(lines)
tag=rb0.index.values[-1]
factory.addCurveLoop(lines, tag=ltag)
#print(loop)
loops.append(ltag)
all_lines.append(lines)
tag += 1
ltag += 1
for contour in tqdm(ddf.index.levels[0][1:]):
rb=ddf.loc[contour].copy()
if not shapely.geometry.LinearRing(rb[['lon','lat']].values).is_ccw:# check for clockwise orientation
rb=ddf.loc[contour].iloc[::-1].reset_index(drop=True)
rb.index=rb.index+tag
rb['bounds']=[[i,i+1] for i in rb.index]
rb['bounds']=rb.bounds.values.tolist()[:-1]+[[rb.index[-1],rb.index[0]]] # fix last one
for row in rb.itertuples(index=True, name='Pandas'):
factory.addPoint(getattr(row, "lon"),getattr(row, "lat"),getattr(row, "z"),getattr(row, "lc"),getattr(row, "Index"))
for row in rb.itertuples(index=True, name='Pandas'):
factory.addLine(getattr(row, "bounds")[0],getattr(row, "bounds")[1],getattr(row, "Index"))
lines=rb.index.values
all_lines.append(lines)
tag=rb.index.values[-1]+1
factory.addCurveLoop(lines,tag=ltag)
# print(tag)
loops.append(ltag)
islands.append(lines)
all_lines.append(lines)
tag += 1
ltag += 1
factory.addPlaneSurface(loops)
logger.info('synchronize')
factory.synchronize()
## Group open boundaries lines
for key,values in open_lines.items():
gmsh.model.addPhysicalGroup(1, values,1000-int(key))
## Group land boundaries lines
for key,values in land_lines.items():
gmsh.model.addPhysicalGroup(1, values,1000-int(key))
ntag=1
for k in tqdm(range(len(islands))):
gmsh.model.addPhysicalGroup(1, islands[k], 2000+ntag)
ntag += 1
ps = gmsh.model.addPhysicalGroup(2, [1])
gmsh.model.setPhysicalName(2, ps, "MyMesh")
flat_list = [item for sublist in all_lines for item in sublist]
ols=[j for i in list(open_lines.values()) for j in i]
lists = [x for x in flat_list if x not in ols]
model.mesh.field.add("Distance", 1)
model.mesh.field.setNumbers(1, "CurvesList", lists)
SizeMin = kwargs.get("SizeMin",.1)
SizeMax = kwargs.get("SizeMax",.5)
DistMin = kwargs.get("DistMin",.01)
DistMax = kwargs.get("DistMax",.2)
model.mesh.field.add("Threshold", 2);
model.mesh.field.setNumber(2, "InField", 1);
model.mesh.field.setNumber(2, "SizeMin", SizeMin);
model.mesh.field.setNumber(2, "SizeMax", SizeMax);
model.mesh.field.setNumber(2, "DistMin", DistMin);
model.mesh.field.setNumber(2, "DistMax", DistMax);
# Set bgmesh
bgmesh = kwargs.get('bgmesh', None)
if bgmesh == 'auto':
try:
logger.info('Read DEM')
dem = pdem.dem(**kwargs)
res_min = kwargs.get('resolution_min',.01)
res_max = kwargs.get('resolution_max',.5)
logger.info('Evaluate bgmesh')
w = make_bgmesh(dem.Dataset,res_min, res_max)
path = kwargs.get('rpath','.')
if not os.path.exists(path): # check if run folder exists
os.makedirs(path)
logger.info('Save bgmesh to {}/bgmesh/bgmesh.pos'.format(path))
fpos = path + '/bgmesh/bgmesh.pos'
to_sq(w,fpos) # save bgmesh
kwargs.update({'bgmesh':fpos})
model.mesh.field.setNumber(2, "StopAtDistMax", 1);
# Merge a post-processing view containing the target anisotropic mesh sizes
gmsh.merge(fpos)
model.mesh.field.add("PostView", 3)
model.mesh.field.setNumber(3, "ViewIndex", 0)
model.mesh.field.add("Min", 4)
model.mesh.field.setNumbers(4, "FieldsList", [2,3])
model.mesh.field.setAsBackgroundMesh(4)
except:
logger.warning('bgmesh failed... continuing without background mesh size')
model.mesh.field.setAsBackgroundMesh(2)
else:
model.mesh.field.setAsBackgroundMesh(2)
gmsh.option.setNumber('Mesh.MeshSizeExtendFromBoundary',0)
gmsh.option.setNumber('Mesh.MeshSizeFromPoints',0)
gmsh.option.setNumber('Mesh.MeshSizeFromCurvature',0)
logger.info('execute')
gmsh.model.mesh.generate(2)
# ... and save it to disk
rpath = kwargs.get('rpath', '.')
logger.info('save mesh')
# gmsh.option.setNumber("Mesh.SaveAll", 1)
gmsh.write(rpath + '/gmsh/mymesh.msh')
# gmsh.write('mymesh.vtk')
gmsh.finalize()
def test_elevation(tmpdir, dic):
# Just elevation
df = pdem.dem(**dic, dem_source=DEM_SOURCE) # get dem
df.adjust(natural_earth)
assert np.isnan(df.Dataset.adjusted.values).sum() == 0
def test_dem_adjust(natural_earth, dem_source, window):
# Just elevation
df = pdem.dem(**window, dem_source=dem_source) # get dem
df.adjust(natural_earth)
assert np.isnan(df.Dataset.adjusted.values).sum() == 0
def jigsaw(**kwargs):
logger.info("Creating grid with JIGSAW\n")
geometry = kwargs.get("geometry", None)
# Set bgmesh
bgmesh = kwargs.get("bgmesh", None)
if bgmesh == "auto":
try:
logger.info("Read DEM")
dem = pdem.dem(**kwargs)
res_min = kwargs.get("resolution_min", 0.01)
res_max = kwargs.get("resolution_max", 0.5)
dhdx = kwargs.get("dhdx", 0.15)
logger.info("Evaluate bgmesh")
w = hfun(dem.Dataset.elevation,
resolution_min=res_min,
resolution_max=res_max,
dhdx=dhdx) # resolution in lat/lon degrees
path = kwargs.get("rpath", "./bgmesh/")
if not os.path.exists(path): # check if run folder exists
os.makedirs(path)
logger.info("Save bgmesh to {}bgmesh.nc".format(path))
w.to_netcdf(path + "bgmesh.nc") # save bgmesh
kwargs.update({"bgmesh": path + "bgmesh.nc"})
except:
logger.warning(
"bgmesh failed... continuing without background mesh size")
if isinstance(geometry, dict):
df, bmindx = tag_(**kwargs)
gr = jigsaw_(df, bmindx, **kwargs)
elif isinstance(geometry, str):
if geometry == "global":
bgmesh = hfun_(kwargs.get("coastlines", None),
kwargs.get("res", 0.1), kwargs.get("R", 1.0))
kwargs.update({"bgmesh": bgmesh})
df = sgl(**kwargs)
bmindx = df.tag.min()
gr = jigsaw_(df, bmindx, **kwargs)
convert = kwargs.get("to_lat_lon", True)
if convert:
# convert to lat/lon
u, v = gr.SCHISM_hgrid_node_x.values, gr.SCHISM_hgrid_node_y.values
rlon, rlat = to_lat_lon(u, v, R=kwargs.get("R", 1.0))
gr["SCHISM_hgrid_node_x"].values = rlon
gr["SCHISM_hgrid_node_y"].values = rlat
else:
df = jcustom(**kwargs)
bmindx = df.tag.min()
gr = jigsaw_(df, bmindx, **kwargs)
return gr
def test_answer(tmpdir, kwargs):
df = pdem.dem(**kwargs)
assert np.isnan(df.Dataset.elevation.values).sum() == 0
def test_answer(dem_source, kwargs):
df = pdem.dem(dem_source=dem_source, **kwargs)
assert np.isnan(df.Dataset.elevation.values).sum() == 0
def jigsaw(**kwargs):
logger.info('Creating grid with JIGSAW\n')
geometry = kwargs.get('geometry', None)
# Set bgmesh
bgmesh = kwargs.get('bgmesh', None)
if bgmesh == 'auto':
try:
logger.info('Read DEM')
dem = pdem.dem(**kwargs)
res_min = kwargs.get('resolution_min', .01)
res_max = kwargs.get('resolution_max', .5)
dhdx = kwargs.get('dhdx', .15)
logger.info('Evaluate bgmesh')
w = hfun(dem.Dataset.elevation,
resolution_min=res_min,
resolution_max=res_max,
dhdx=dhdx) # resolution in lat/lon degrees
path = kwargs.get('rpath', './bgmesh/')
if not os.path.exists(path): # check if run folder exists
os.makedirs(path)
logger.info('Save bgmesh to {}bgmesh.nc'.format(path))
w.to_netcdf(path + 'bgmesh.nc') # save bgmesh
kwargs.update({'bgmesh': path + 'bgmesh.nc'})
except:
logger.warning(
'bgmesh failed... continuing without background mesh size')
if isinstance(geometry, dict):
df, bmindx = tag_(**kwargs)
gr = jigsaw_(df, bmindx, **kwargs)
elif isinstance(geometry, str):
if geometry == 'global':
bgmesh = hfun_(kwargs.get('coastlines', None),
kwargs.get('res', .1), kwargs.get('R', 1.))
kwargs.update({'bgmesh': bgmesh})
df = sgl(**kwargs)
bmindx = df.tag.min()
gr = jigsaw_(df, bmindx, **kwargs)
convert = kwargs.get('to_lat_lon', True)
if convert:
# convert to lat/lon
u, v = gr.SCHISM_hgrid_node_x.values, gr.SCHISM_hgrid_node_y.values
rlon, rlat = to_lat_lon(u, v, R=kwargs.get('R', 1.))
gr['SCHISM_hgrid_node_x'].values = rlon
gr['SCHISM_hgrid_node_y'].values = rlat
else:
df = jcustom(**kwargs)
bmindx = df.tag.min()
gr = jigsaw_(df, bmindx, **kwargs)
return gr
