Prepare for 1.21 release (#1786)

NEWS.md

@@ -1,5 +1,25 @@
 # Meep Release Notes
 
+## Meep 1.21.0
+
+10/12/2021
+
+* Support for checkpointing structure and fields ([#1715], [#1738]).
+
+* Support for multithreading via OpenMP ([#1628]).
+
+* Support for cache-oblivious loop tiling of the E-from-D and H-from-B field updates ([#1655]).
+
+* Support for load balancing parallel simulations using timing measurements ([#1775]).
+
+* Support for automatic DFT decimation ([#1732]).
+
+* Support for adjoint gradients in cylindrical coordinates ([#1749]).
+
+* Revamped convergence criteria for DFT fields ([#1740]).
+
+* Various bugfixes ([#1593], [#1769]), performance enhancements ([#1730], [#1763]), minor improvements, and additional documentation.
+
 ## Meep 1.20.0
 
 8/11/2021

configure.ac

@@ -1,13 +1,13 @@
 # Process this file with autoconf to produce a configure script.
 
-AC_INIT([meep],[m4_esyscmd(./version.sh 1.21.0-beta)])
+AC_INIT([meep],[m4_esyscmd(./version.sh 1.21.0)])
 AC_CONFIG_SRCDIR(src/step.cpp)
 
 # Shared-library version number; indicates api compatibility, and is
 # not the same as the "public" version number.  (Don't worry about this
 # except for public releases.) Note that any change to a C++ class
 # definition (in the .hpp file) generally breaks binary compatibility.
-SHARED_VERSION_INFO="25:0:0" # CURRENT:REVISION:AGE
+SHARED_VERSION_INFO="26:0:0" # CURRENT:REVISION:AGE
 
 AM_INIT_AUTOMAKE([foreign color-tests parallel-tests silent-rules 1.11])
 AM_SILENT_RULES(yes)

doc/docs/FAQ.md

@@ -489,6 +489,6 @@ The first approach in the weak-scattering (undepleted pump) approximation would
 
 The second approach is based on a full nonlinear simulation of the Raman process. This involves modeling the populations of the atomic vibrational states corresponding to the Raman bands using [saturable gain and absorption](Materials.md#saturable-gain-and-absorption).
 
-### Does Meep support adjoint-based optimization?
+### Does Meep support photonics inverse design?
 
 Yes. Meep has an [adjoint solver](Python_Tutorials/Adjoint_Solver.md) which can be used for inverse design and density-based topology optimization in which the degrees of freedom are a grid of $\varepsilon$ voxels.  (Of course, you can always use finite differences or similar methods to compute sensitivities or gradients for other parameters, as well as derivative-free optimization methods. However, such methods become increasingly impractical for ≳ 10 parameters.)

doc/docs/Python_Tutorials/Adjoint_Solver.md

@@ -2,7 +2,9 @@
 # Adjoint Solver
 ---
 
-Meep has a density-based adjoint solver for efficiently computing the gradient of an arbitrary function of the mode coefficients (S-parameters), DFT fields, and far fields (using the near-to-far transformation) with respect to $\varepsilon$ on a discrete spatial grid (i.e., a [`MaterialGrid`](../Python_User_Interface.md#materialgrid) class object) at multiple frequencies over a broad bandwidth. Regardless of the number of degrees of freedom for the grid points, just **two** separate timestepping runs are required. The first run is the "forward" calculation to compute the objective function. The second run is the "adjoint" calculation to compute the gradient of the objective function with respect to the design variables which involves a special type of source distribution and postprocessing of the results (which includes the DFT fields of the design region). This module is implemented entirely in Python using [autograd](https://github.com/HIPS/autograd) and [JAX](https://github.com/google/jax). The adjoint solver supports inverse design and [topology optimization](https://en.wikipedia.org/wiki/Topology_optimization) by providing the functionality to wrap an optimization library around the gradient computation.
+Meep has a density-based adjoint solver for efficiently computing the gradient of an arbitrary function of the mode coefficients (S-parameters), DFT fields, and far fields (using the analytic near-to-far field transformation) with respect to $\varepsilon$ on a discrete spatial grid (a [`MaterialGrid`](../Python_User_Interface.md#materialgrid) class object) at multiple frequencies over a broad bandwidth. Regardless of the number of degrees of freedom for the grid points, just **two** separate timestepping runs are required. The first run is the "forward" calculation to compute the objective function and the DFT fields of the design region. The second run is the "adjoint" calculation to compute the gradient of the objective function with respect to the design variables. The adjoint run involves a special type of source distribution used to compute the DFT fields of the design region. The gradient is computed in post processing using the DFT fields from the forward and adjoint runs. This is all done automatically.
+
+This module is implemented entirely in Python using [autograd](https://github.com/HIPS/autograd) and [JAX](https://github.com/google/jax). The adjoint solver supports inverse design and [topology optimization](https://en.wikipedia.org/wiki/Topology_optimization) by providing the functionality to wrap an optimization library around the gradient computation.
 
 There are six Jupyter notebooks that demonstrate the main features of the adjoint solver.