Example on retrieving and plotting winds#
This is a simple example for how to retrieve and plot winds from 2 radars using PyDDA.
Author: Robert C. Jackson
import pydda
from matplotlib import pyplot as plt
berr_grid = pydda.io.read_grid(pydda.tests.EXAMPLE_RADAR0)
cpol_grid = pydda.io.read_grid(pydda.tests.EXAMPLE_RADAR1)
# Load sounding data and insert as an intialization
berr_grid = pydda.initialization.make_constant_wind_field(
berr_grid, (0.0, 0.0, 0.0), vel_field="corrected_velocity"
)
# Start the wind retrieval. This example only uses the mass continuity
# and data weighting constraints.
Grids, _ = pydda.retrieval.get_dd_wind_field(
[berr_grid, cpol_grid],
Co=1.0,
Cm=256.0,
Cx=0.0,
Cy=0.0,
Cz=0.0,
Cb=0.0,
frz=5000.0,
filter_window=5,
mask_outside_opt=True,
upper_bc=1,
wind_tol=0.5,
engine="scipy",
)
# Plot a horizontal cross section
plt.figure(figsize=(9, 9))
pydda.vis.plot_horiz_xsection_barbs(
Grids,
background_field="reflectivity",
level=6,
w_vel_contours=[5, 10, 15],
barb_spacing_x_km=5.0,
barb_spacing_y_km=15.0,
vmin=0,
vmax=70,
)
plt.show()
# Plot a vertical X-Z cross section
plt.figure(figsize=(9, 9))
pydda.vis.plot_xz_xsection_barbs(
Grids,
background_field="reflectivity",
level=40,
w_vel_contours=[5, 10, 15],
barb_spacing_x_km=10.0,
barb_spacing_z_km=2.0,
vmin=0,
vmax=70,
)
plt.show()
# Plot a vertical Y-Z cross section
plt.figure(figsize=(9, 9))
pydda.vis.plot_yz_xsection_barbs(
Grids,
background_field="reflectivity",
level=40,
barb_spacing_y_km=10.0,
barb_spacing_z_km=2.0,
vmin=0,
vmax=70,
)
plt.show()
## You are using the Python ARM Radar Toolkit (Py-ART), an open source
## library for working with weather radar data. Py-ART is partly
## supported by the U.S. Department of Energy as part of the Atmospheric
## Radiation Measurement (ARM) Climate Research Facility, an Office of
## Science user facility.
##
## If you use this software to prepare a publication, please cite:
##
## JJ Helmus and SM Collis, JORS 2016, doi: 10.5334/jors.119
Failed to import TF-Keras. Please note that TF-Keras is not installed by default when you install TensorFlow Probability. This is so that JAX-only users do not have to install TensorFlow or TF-Keras. To use TensorFlow Probability with TensorFlow, please install the tf-keras or tf-keras-nightly package.
This can be be done through installing the tensorflow-probability[tf] extra.
Welcome to PyDDA 2.1.1
If you are using PyDDA in your publications, please cite:
Jackson et al. (2020) Journal of Open Research Science
Detecting Jax...
Jax/JaxOpt are not installed on your system, unable to use Jax engine.
Detecting TensorFlow...
TensorFlow detected. Checking for tensorflow-probability...
Failed to import TF-Keras. Please note that TF-Keras is not installed by default when you install TensorFlow Probability. This is so that JAX-only users do not have to install TensorFlow or TF-Keras. To use TensorFlow Probability with TensorFlow, please install the tf-keras or tf-keras-nightly package.
This can be be done through installing the tensorflow-probability[tf] extra.
Unable to load both TensorFlow and tensorflow-probability. TensorFlow engine disabled.
No module named 'tf_keras'
False
Calculating weights for radars 0 and 1
Calculating weights for radars 1 and 0
Calculating weights for models...
Starting solver
rmsVR = 6.827303971100176
Total points: 81194
The max of w_init is 0.0
Total number of model points: 0
Nfeval | Jvel | Jmass | Jsmooth | Jbg | Jvort | Jmodel | Jpoint | Max w
0|83859.8222| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000
The gradient of the cost functions is 0.6631357968996561
Nfeval | Jvel | Jmass | Jsmooth | Jbg | Jvort | Jmodel | Jpoint | Max w
10| 1.8782| 41.0864| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 11.3085
Max change in w: 10.561
The gradient of the cost functions is 0.13750649771706358
Nfeval | Jvel | Jmass | Jsmooth | Jbg | Jvort | Jmodel | Jpoint | Max w
20| 0.3524| 18.6065| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 11.8823
Max change in w: 6.008
The gradient of the cost functions is 0.09828068193832484
Nfeval | Jvel | Jmass | Jsmooth | Jbg | Jvort | Jmodel | Jpoint | Max w
30| 0.1953| 10.8039| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 12.4880
Max change in w: 4.003
The gradient of the cost functions is 0.0973043037034497
Nfeval | Jvel | Jmass | Jsmooth | Jbg | Jvort | Jmodel | Jpoint | Max w
40| 0.1245| 7.0774| 0.0000| 0.0000| 0.0000| 0.0000| 0.0000| 16.4854
Max change in w: 5.381
---------------------------------------------------------------------------
KeyboardInterrupt Traceback (most recent call last)
Cell In[1], line 14
8 berr_grid = pydda.initialization.make_constant_wind_field(
9 berr_grid, (0.0, 0.0, 0.0), vel_field="corrected_velocity"
10 )
12 # Start the wind retrieval. This example only uses the mass continuity
13 # and data weighting constraints.
---> 14 Grids, _ = pydda.retrieval.get_dd_wind_field(
15 [berr_grid, cpol_grid],
16 Co=1.0,
17 Cm=256.0,
18 Cx=0.0,
19 Cy=0.0,
20 Cz=0.0,
21 Cb=0.0,
22 frz=5000.0,
23 filter_window=5,
24 mask_outside_opt=True,
25 upper_bc=1,
26 wind_tol=0.5,
27 engine="scipy",
28 )
30 # Plot a horizontal cross section
31 plt.figure(figsize=(9, 9))
File ~/work/PyDDA/PyDDA/pydda/retrieval/wind_retrieve.py:1472, in get_dd_wind_field(Grids, u_init, v_init, w_init, engine, **kwargs)
1465 w_init = new_grids[0]["w"].values.squeeze()
1467 if (
1468 engine.lower() == "scipy"
1469 or engine.lower() == "jax"
1470 or engine.lower() == "auglag"
1471 ):
-> 1472 return _get_dd_wind_field_scipy(
1473 new_grids, u_init, v_init, w_init, engine, **kwargs
1474 )
1475 elif engine.lower() == "tensorflow":
1476 return _get_dd_wind_field_tensorflow(
1477 new_grids, u_init, v_init, w_init, **kwargs
1478 )
File ~/work/PyDDA/PyDDA/pydda/retrieval/wind_retrieve.py:602, in _get_dd_wind_field_scipy(Grids, u_init, v_init, w_init, engine, points, vel_name, refl_field, u_back, v_back, z_back, frz, Co, Cm, Cx, Cy, Cz, Cb, Cv, Cmod, Cpoint, cvtol, gtol, Jveltol, Ut, Vt, low_pass_filter, mask_outside_opt, weights_obs, weights_model, weights_bg, max_iterations, mask_w_outside_opt, filter_window, filter_order, min_bca, max_bca, upper_bc, model_fields, output_cost_functions, roi, wind_tol, tolerance, const_boundary_cond, max_wind_mag)
600 parameters.print_out = False
601 if engine.lower() == "scipy":
--> 602 winds = fmin_l_bfgs_b(
603 J_function,
604 winds,
605 args=(parameters,),
606 maxiter=max_iterations,
607 pgtol=tolerance,
608 bounds=bounds,
609 fprime=grad_J,
610 callback=_vert_velocity_callback,
611 )
612 else:
614 def loss_and_gradient(x):
File /usr/share/miniconda/envs/pydda-docs/lib/python3.12/site-packages/scipy/optimize/_lbfgsb_py.py:281, in fmin_l_bfgs_b(func, x0, fprime, args, approx_grad, bounds, m, factr, pgtol, epsilon, iprint, maxfun, maxiter, disp, callback, maxls)
269 callback = _wrap_callback(callback)
270 opts = {'disp': disp,
271 'iprint': iprint,
272 'maxcor': m,
(...) 278 'callback': callback,
279 'maxls': maxls}
--> 281 res = _minimize_lbfgsb(fun, x0, args=args, jac=jac, bounds=bounds,
282 **opts)
283 d = {'grad': res['jac'],
284 'task': res['message'],
285 'funcalls': res['nfev'],
286 'nit': res['nit'],
287 'warnflag': res['status']}
288 f = res['fun']
File /usr/share/miniconda/envs/pydda-docs/lib/python3.12/site-packages/scipy/optimize/_lbfgsb_py.py:469, in _minimize_lbfgsb(fun, x0, args, jac, bounds, disp, maxcor, ftol, gtol, eps, maxfun, maxiter, iprint, callback, maxls, finite_diff_rel_step, workers, **unknown_options)
461 _lbfgsb.setulb(m, x, low_bnd, upper_bnd, nbd, f, g, factr, pgtol, wa,
462 iwa, task, lsave, isave, dsave, maxls, ln_task)
464 if task[0] == 3:
465 # The minimization routine wants f and g at the current x.
466 # Note that interruptions due to maxfun are postponed
467 # until the completion of the current minimization iteration.
468 # Overwrite f and g:
--> 469 f, g = func_and_grad(x)
470 elif task[0] == 1:
471 # new iteration
472 n_iterations += 1
File /usr/share/miniconda/envs/pydda-docs/lib/python3.12/site-packages/scipy/optimize/_differentiable_functions.py:404, in ScalarFunction.fun_and_grad(self, x)
402 self._update_x(x)
403 self._update_fun()
--> 404 self._update_grad()
405 return self.f, self.g
File /usr/share/miniconda/envs/pydda-docs/lib/python3.12/site-packages/scipy/optimize/_differentiable_functions.py:366, in ScalarFunction._update_grad(self)
364 if self._orig_grad in FD_METHODS:
365 self._update_fun()
--> 366 self.g = self._wrapped_grad(self.x, f0=self.f)
367 self.g_updated = True
File /usr/share/miniconda/envs/pydda-docs/lib/python3.12/site-packages/scipy/optimize/_differentiable_functions.py:39, in _ScalarGradWrapper.__call__(self, x, f0, **kwds)
35 def __call__(self, x, f0=None, **kwds):
36 # Send a copy because the user may overwrite it.
37 # The user of this class might want `x` to remain unchanged.
38 if callable(self.grad):
---> 39 g = np.atleast_1d(self.grad(np.copy(x), *self.args))
40 elif self.grad in FD_METHODS:
41 g, dct = approx_derivative(
42 self.fun,
43 x,
44 f0=f0,
45 **self.finite_diff_options,
46 )
File ~/work/PyDDA/PyDDA/pydda/cost_functions/cost_functions.py:513, in grad_J(winds, parameters)
503 elif parameters.engine == "scipy":
504 winds = np.reshape(
505 winds,
506 (
(...) 511 ),
512 )
--> 513 grad = _cost_functions_numpy.calculate_grad_radial_vel(
514 parameters.vrs,
515 parameters.els,
516 parameters.azs,
517 winds[0],
518 winds[1],
519 winds[2],
520 parameters.wts,
521 parameters.weights,
522 parameters.rmsVr,
523 coeff=parameters.Co,
524 upper_bc=parameters.upper_bc,
525 )
527 if parameters.Cm > 0:
528 grad += _cost_functions_numpy.calculate_mass_continuity_gradient(
529 winds[0],
530 winds[1],
(...) 537 upper_bc=parameters.upper_bc,
538 )
File ~/work/PyDDA/PyDDA/pydda/cost_functions/_cost_functions_numpy.py:128, in calculate_grad_radial_vel(vrs, els, azs, u, v, w, wts, weights, rmsVr, coeff, upper_bc)
120 for i in range(len(vrs)):
121 v_ar = (
122 np.cos(els[i]) * np.sin(azs[i]) * u
123 + np.cos(els[i]) * np.cos(azs[i]) * v
124 + np.sin(els[i]) * (w - np.abs(wts[i]))
125 )
127 x_grad = (
--> 128 2 * (v_ar - vrs[i]) * np.cos(els[i]) * np.sin(azs[i]) * weights[i]
129 ) * lambda_o
130 y_grad = (
131 2 * (v_ar - vrs[i]) * np.cos(els[i]) * np.cos(azs[i]) * weights[i]
132 ) * lambda_o
133 z_grad = (2 * (v_ar - vrs[i]) * np.sin(els[i]) * weights[i]) * lambda_o
KeyboardInterrupt: