emopt.adjoint_method¶

This modules provides the definition for the AdjointMethod class. Given an electromagnetic structure (which is simulated using the FDFD class) and a merit function which describes the ‘performance’ of that electromagnetic structure, the AdjointMethod class defines the methods needed in order to calculate the gradient of that merit function with respect to a set of user-defined design variables.

Notes

Mathematically, the adjoint method calculates the gradient of a function \(F(\mathbf{E}, \mathbf{H})\) which has an explicit dependence on the electric and magnetic fields (\(\mathbf{E}\) and \(\mathbf{H}\)). Assuming we have expressed Maxwell’s equations as a discretized linear system of equations, one can show [1] that the derivatives of \(F\) are given by

\[\frac{d F}{d p_i} = -2\Re\left\{ y^T \frac{\partial A}{\partial p_i} x\right\}\]

where \(x\) contains the electric and magnetic fields, \(y\) contains a second set of ‘adjoint’ fields which are found by solving a second set of linear system of equations which consist of the transposed Maxwell’s equations, and \(\partial A / \partial p_i\) describes how the materials in the system change with respect to changes to the design variables of the system.

The AdjointMethod class does most of the work needed to compute \(x\), \(y\), \(\partial A / \partial p_i\), and the gradient \(\nabla_\mathbf{p}F\).

More generally, we may specify a function of which depndends not only on the fields, but also explicitly on the design variables. In this case, the function is given by

\[F \rightarrow F(\mathbf{E}, \mathbf{H}, p_1, p_2, \cdots, p_N)\]

The derivative of this function with respect to the i’th design variable, \(p_i\) is given by

\[\frac{d F}{d p_i} = -2\Re\left\{ y^T \frac{\partial A}{\partial p_i} x\right\} + \frac{\partial F}{\partial p_i}\]

The derivative with respect to \(p_i\) on the right-hand side is assumed to be known, thus very general figures of merit can be computed using the adjoint method.

Note: This file uses MPI for parallelism. As a result, return types and values will depend on the RANK of the node running the code.

Examples

The AdjointMethod class is used by extending the AdjointMethod base class. At a minimum, four methods must be defined in the inheriting class. As an example, a custom AdjointMethod class might look like

class MyAdjointMethod(AdjointMethod):

    def __init__(self, sim, myparam, step=1e-8):
        super(MyAdjointMethod, self).__init__(sim, step=step)
        self._myparam = myparam

    def update_system(self, params):
        # update system based on values in params
        ...

    def calc_fom(self, sim, params):
        # calculate figure of merit. We assume a simulation has already
        # been run and the fields are contained in the sim object which is
        # of type FDFD
        ...
        return fom

    def calc_dFdx(self, sim, params):
        # calculate derivative of F with respect to fields which is used as
        # source in adjoint simulation
        ...
        return dFdx

    def calc_grad_p(self, sim, params):
        # calculte the gradient of F with respect to the design variables,
        # holding the fields constant
        ...
        return grad_y

Here AdjointMethod.update_system() updates the the system based on the current set of design parameters, AdjointMethod.calc_fom() calculates the value of F(mathbf{E}, mathbf{H}, y_1, y_2, cdots, y_N) for the specified set of design parameters in params, AdjointMethod.calc_dFdx() calculates the derivative of \(F\) with respect to the relevant field components, and AdjointMethod.calc_grad_y() calculates the gradient of F with respect to the non-field-dependent quantities in F.

In order to verify that the AdjointMethod.calc_fom(), AdjointMethod.calc_dFdx(), and AdjointMethod.calc_grad_y() functions are consistent, the gradient accuracty should always be verified. The AdjointMethod base class defines a function to do just this. For example, using the MyAdjointMethod that we have just defined, we might do:

# set up an FDFD simulation object called 'sim'
...

# create the adjoint method object
am = MyAdjointMethod(sim, myparam)

# check the gradient
init_params = ...
am.check_gradient(init_params, indices=np.arange(0,10))

In this example, we check the accuracy of the gradients computed for a given initial set of design parameters called init_params. We restrict the check to the first ten components of the gradient in order to speed things up.

In addition to the adjoint method base class, there are a number of application-specific implementations which you may find useful. In particular, the AdjointMethodFM2D class provides a simplified interface for computing the gradient of a function that depends not only on the fields but also the permittivity and permeability. In addition to the functions specified above, the user must implement an additional function AdjointMethodFM.calc_dFdm() which must compute the derivative of the figure of merit \(F\) with respect to the permittivity and permeability, \(\epsilon\) and \(\mu\). An example of such a function would be, for example, the total absorption of electromagnetic energy in a domain.

Furthermore, in electromagnetics, efficiencies make common figures of merit. In many cases, this efficiency is defined in terms of the ratio of a calculated power to the total source power of the system. Because differentiating these power-normalized quantities (which depend on the fields and the permittivity/permeability) is rather laborious, this functionality is implemented in the AdjointMethodPNF2D and AdjointMethodPNF3D classes for convenience.

See also

emopt.fdfd.FDFD: Base class for simulators supported by AdjointMethod.
emopt.optimizer.Optimizer: Primary application of AdjointMethod to optimization.

References

[1]	Michaels and E. Yablonovitch, “Leveraging continuous material averaging for inverse electromagnetic design,” Opt. Express 26, 31717-31737 (2018)

class emopt.adjoint_method.AdjointMethod(sim, step=1e-08)¶

Bases: future.types.newobject.newobject

Adjoint Method Class

Defines the core functionality needed to compute the gradient of a function of the form

with respect to an arbitrary set of design variables \(\vec{p}\). In general, the gradient is given by

\[\nabla F = \nabla_\mathrm{AM} F + \frac{\partial F}{\partial \vec{p}}\]

where \(\nabla_\mathrm{AM} F\) is the gradient of \(F\) computed using the adjoint method, and the remaining gradient term corresponds to any explicit dependence of the figure of merit on the design parameters. The derivatives of these quantities are assumed to be known and should be computed using AdjointMethod.calc_grad_p() function.

In order to use the AdjointMethod class, it should extended and the abstract methods AdjointMethod.update_system(), AdjointMethod.calc_fom(), AdjointMethod.calc_dFdx(), and AdjointMethod.calc_grad_p() should be implemented for the desired application.

Notes

Currently source derivatives are not supported. If needed, this should not be too difficult to achieve by extending AdjointMethod

Parameters:	sim (emopt.simulation.MaxwellSolver) – Simulation object step (float) – Step sized used in the calculation of \(\partial A / \partial p_i\)

sim¶

Simulation object

Type:	emopt.simulation.MaxwellSolver

step¶

Step sized used in the calculation of \(\partial A / \partial p_i\)

Type:	float

update_system(params)¶: (ABSTRACT METHOD) Update the geometry of the system.

calc_fom(sim, params)¶: (ABSTRACT METHOD) Calculate the figure of merit.

calc_dFdx(sim, params)¶: (ABSTRACT METHOD) Calculate the derivative of the figure of merit with respect to the electric and magnetic field vectors.

get_update_boxes(sim, params)¶: Define update boxes which specify which portion of the underlying spatial grid is modified by each design variable.

fom(params)¶: Get the figure of merit.

calc_gradient(sim, params)¶: Calculate the figure of merit in a general way.

gradient(params)¶: Get the gradient for at the current set of design parameter values.

calc_dFdx(sim, params)

Calculate the derivative of the figure of merit with respect to the vector containing the electric and magnetic fields.

In order to calculate the gradient of the figure of merit, an adjoint simulation must first be run. The sources in the adjoint simulation are given by \(\partial F / \partial x\) where \(F\) is the figure of merit and \(x\) is a vector containing the electric and magnetic fields contained on a discreter grid. Because we are differentiating with respect to a vector, the resulting derivative will also be a vector.

This function must be overriden and implemented to calculate the derivative of the figure of merit defined in calc_fom().

The exact format of \(x\) depends on the exact type of emopt.fdfd.FDFD object which generated it. Consult emopt.fdfd for details.

See also

emopt.fdfd.FDFD(): Base class for simulators which generate \(x\)

calc_fom(sim, params)

Calculate the figure of merit.

Notes

This function is called by the AdjointMethod.fom() function. In this case, update_system(params) and sim.solve_forward() are guaranteed to be called before this function is executed.

If this function is called outside of the AdjointMethod.fom() function (which is not advised), it is up to the caller to ensure that the emopt.FDFD.solve_forward() has been run previously.

Parameters:	sim (emopt.fdfd.FDFD) – Simulation object params (numpy.ndarray) – 1D vector containing design parameter values.

calc_grad_p(sim, params)¶

Compute the gradient of of the figure of merit with respect to the design variables \(\vec{p}\), holding the fields constant.

This function should calculate the list of partial derivatives of the figure of merit with respect to each design variable

This allows us to include an explicit dependence on the design variables in our figure of merit. This is useful for imposing constraints in an optimization.

Notes

This function is executed in parallel on all nodes. If execution on master node is desired, you can either apply the @run_on_master decorator or use if(NOT_PARALLEL).

Parameters:	sim (emoptg.fdfd.FDFD) – The FDFD object params (numpy.ndarray) – The array containing the current set of design parameters
Returns:	The partial derivatives with respect to the design variables.
Return type:	numpy.ndarray

calc_gradient(sim, params)

Calculate the gradient of the figure of merit.

The gradient of the figure of merit is computed by running a forward simulation, adjoint simulation, and then computing the derivatives of the system matrix \(A\) with respect to the design parameters of the system, i.e. \(\partial A / \partial p_i\). In the most general case, we can compute this derivative using finite differences. This involves perturbing each design variable of the system by a small amount one at a time and updating \(A\). Doing so allows us to approximate the derivative as

\[\frac{\partial A}{\partial p_i} \approx \frac{A(p_i + \Delta p) - A(p_i)}{\Delta p}\]

So long as \(\Delta p\) is small enough, this approximation is quite accurate.

This function handles this process.

Notes

1. This function is called after the forward and adjoint simulations have been executed.

2. Technically, a centered difference would be more accurate, however this whole implementation relies on mesh smoothing which allows us to make very small steps \(\Delta p\) and thus in reality, the benefit is negligable.

Parameters:	sim (FDFD) – Simulation object. sim = self.sim params (numpy.array or list of floats) – List of design parameters.
Returns:	(Master node only) Gradient of figure of merit, i.e. list of derivatives of fom with respect to each design variable
Return type:	numpy.array

check_gradient(params, indices=[], plot=True, verbose=True, return_gradients=False, fd_step=1e-10)¶

Verify that the gradient is accurate.

It is highly recommended that the accuracy of the gradients be checked prior to being used. If the accuracy is above ~1%, it is likely that there is an inconsitency between how the figure of merit and adjoint sources (dFdx) are being computed.

The adjoint method gradient error is evaluated by comparing the gradient computed using the adjoint method to a gradient computed by direct finite differences. In other words, the “correct” derivatives to which the adjoint method gradient is compared are given by

\[\frac{\partial F}{\partial p_i} \approx \frac{F(p_i + \Delta p) - F(p_i)}{\Delta p}\]

Note that this method for calculating the gradient is not used in a practical setting because it requires performing N+1 simulations in order to compute the gradient with respect to N design variables (compared to only 2 simulations in the case of the adjoint method).

Parameters:	params (numpy.ndarray) – design parameters indices (list or numpy.ndarray) – list of gradient indices to check. An empty list indicates that the whole gradient should be verified. A subset of indices may be desirable for large problems. (default = []) plot (bool (optional)) – Plot the gradients and errors (default = True) verbose (bool (optional)) – If True, print progress (default = True) return_gradients (bool) – If True, return the gradient arrays (default = False)
Returns:	Relative error in gradient.
Return type:	float

fom(params)

Run a forward simulation and calculate the figure of merit.

Notes

The simualtion is performed in parallel with the help of all of the MPI node, however the calculation of the figure of merit itself is currently only performed on the master node (RANK == 0)

Parameters:	params (numpy.ndarray) – List of design parameters of the system
Returns:	(Master node only) The figure of merit \(F(\mathbf{E},\mathbf{H} ; \mathbf{p})\)
Return type:	float

get_update_boxes(sim, params)

Get update boxes used to speed up the updating of A.

In order to compute the gradient, we need to calculate how A changes with respect to modification of the design variables. This generally requires updating the material values in A. We can speed this process up by only updating the part of the system which is affect by the modification of each design variable.

By default, the update boxes cover the whole simulation area. This method can be overriden in order to modify this behavior.

Parameters:

sim (FDFD) – Simulation object. sim = self.sim
params (numpy.array or list of floats) – List of design parameters.

Returns:

Either a list of tuples or a list of lists of tuples containing
(xmin, xmax, ymin, ymax) in 2D and (xmin, xmax, ymin, ymax, zmin,
zmax) in 3D which describes which portion of the system should be
update during gradient calculations.

gradient(params)

Manage the calculation of the gradient figure of merit.

To calculate the gradient, we update the system, run a forward and adjoint simulation, and then calculate the gradient using calc_gradient(). Most of these operations are done in parallel using MPI.

Parameters:	params (numpy.ndarray) – List of design parameters of the system
Returns:	(Master node only) The gradient of the figure of merit computed with respect to the design variables
Return type:	numpy.ndarray

step

Step size used for numerical differentiation of \(A\)

Getter:	Returns the step size.
Setter:	Sets the step size
Type:	float

update_system(params)

Update the geometry/material distributions of the system.

In order to calculate the gradient of a figure of merit, we need to define a mapping between the abstract design parameters of the system (which are contained in the vector params) and the underlying geometry or material distribution which makes up the physical system. We define this mapping here.

Notes

In general, calculation of the gradient involves calling this function once per design variable. In other words, if len(params) is equal to N, then this method is called at least N times in order to calculate the gradient. For cases where N is large, it is recommended an effort be made to avoid performing very costly operations in this method.

Parameters:	params (numpy.ndarray) – 1D array containing design parameter values (one value per design parameter)

class emopt.adjoint_method.AdjointMethodFM2D(sim, step=1e-08)¶

Bases: emopt.adjoint_method.AdjointMethod

Define an AdjointMethod which simplifies the calculation of gradients which are a function of the materials (eps and mu) in 2D problems.

In certain cases, the gradient of a function of the fields, permittivity, and permeability may be desired. Differentiating the function with respect to the permittivity and permeability shares many of the same calculations in common with AdjointMethod.calc_gradient(). In order to maximize performance and simplify the implementation of material-dependent figures of merit, this class reimplements the calc_gradient() function.

sim¶

The simulation object

Type:	`emopt.fdfd.FDFD`

step¶

The step size used by gradient calculation (default = False)

Type:	float (optional)

calc_dFdm(sim, params)¶

Calculate the derivative of F with respect to \(\epsilon\), \(\epsilon^*\), \(\mu\), and \(\mu^*\)

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The derivatives of F with respect to spatially-dependent eps and mu and their complex conjugates. These derivatives should be arrays with dimension (M,N) and should be returned in a tuple with the format (dFdeps, dFdeps_conf, dFdmu, dFdmu_conj)
Return type:	tuple of numpy.array

calc_gradient(sim, params)¶

Calculate the gradient of a figure of merit which depends on the permittivity and permeability.

Parameters:	sim (FDFD) – Simulation object. sim = self.sim params (numpy.array or list of floats) – List of design parameters.
Returns:	(Master node only) Gradient of figure of merit, i.e. list of derivatives of fom with respect to each design variable
Return type:	numpy.array

class emopt.adjoint_method.AdjointMethodMO(ams, step=1e-06)¶

Bases: emopt.adjoint_method.AdjointMethod

An AdjointMethod object for an ensemble of different figures of merit (Multi-objective adjoint method).

In many situations, it is desirable to calculate the sensitivities of a structure corresponding to multiple objective functions. A simple common exmaple of this a broadband figure of merit which considers the performance of structure at a range of different excitation frequencies/wavelengths. In other cases, it may be desirable to calculate a total sensitivity which is made up of two different figures of merit which are calculated for the same excitation.

In either case, we need a way to easily handle these more complicated figures of merits and their gradients (i.e. the sensitivities). This class provides a simple interface to do just that. By overriding calc_total_fom and calc_total_gradient, you can build up more complicated figures of merit.

Parameters:	ams (list of `AdjointMethod`) – A list containing extended AdjointMethod objects

adjoint_methods¶

A list containing extended AdjointMethod objects

Type:	list of `AdjointMethod`

adjoint_methods

calc_dFdx(sim, params)¶

Calculate the derivative of the figure of merit with respect to the vector containing the electric and magnetic fields.

In order to calculate the gradient of the figure of merit, an adjoint simulation must first be run. The sources in the adjoint simulation are given by \(\partial F / \partial x\) where \(F\) is the figure of merit and \(x\) is a vector containing the electric and magnetic fields contained on a discreter grid. Because we are differentiating with respect to a vector, the resulting derivative will also be a vector.

This function must be overriden and implemented to calculate the derivative of the figure of merit defined in calc_fom().

The exact format of \(x\) depends on the exact type of emopt.fdfd.FDFD object which generated it. Consult emopt.fdfd for details.

See also

emopt.fdfd.FDFD(): Base class for simulators which generate \(x\)

calc_fom(sim, params)¶: Calculate the figure of merit.

calc_grad_p(sim, params)¶

Compute the gradient of of the figure of merit with respect to the design variables \(\vec{p}\), holding the fields constant.

This function should calculate the list of partial derivatives of the figure of merit with respect to each design variable

This allows us to include an explicit dependence on the design variables in our figure of merit. This is useful for imposing constraints in an optimization.

Notes

This function is executed in parallel on all nodes. If execution on master node is desired, you can either apply the @run_on_master decorator or use if(NOT_PARALLEL).

Parameters:	sim (emoptg.fdfd.FDFD) – The FDFD object params (numpy.ndarray) – The array containing the current set of design parameters
Returns:	The partial derivatives with respect to the design variables.
Return type:	numpy.ndarray

calc_total_fom(foms)¶

Calculate the ‘total’ figure of merit based on a list of evaluated objective functions.

The user should override this function in order to define how all of the individual figures of merit are combined to form a single ‘total’ figure of merit. This may be a sum of the input FOMs, a minimax of the FOMs, etc. A common example is to combine figures of merit calculated for different wavelengths of operation.

See also

emopt.fomutils: functions which may be useful for combining figures of merit

Parameters:	foms (list of float) – List containing individual FOMs which are used to compute the total figure of merit.
Returns:	The total figure of merit
Return type:	float

calc_total_gradient(foms, grads)¶

Calculate the ‘total’ gradient of a figure of merit based on a list of evaluated objective functions.

The user should override this function in order to define the gradient of the total figure of merit.

See also

emopt.fomutils: functions which may be useful for combining figures of merit and their gradients.

Parameters:	foms (list) – List of individual foms grads (list) – List of individual grads
Returns:	1D numpy array containing total gradient. note: the output vector should have the same shape as the input vectors contained in grads
Return type:	numpy.ndarray

check_gradient(params, indices=[], plot=True, verbose=True, return_gradients=False, fd_step=1e-10)¶

Check the gradient of an multi-objective AdjointMethod.

Parameters:	params (numpy.ndarray) – design parameters indices (list or numpy.ndarray) – list of gradient indices to check. An empty list indicates that the whole gradient should be verified. A subset of indices may be desirable for large problems. (default = [])
Returns:	Relative error in gradient.
Return type:	float

fom(params)¶

Calculate the total figure of merit.

Notes

Overrides AdjointMethod.fom(…)

Parameters:	params (numpy.ndarray) – Design parameters
Returns:	(Master node only) The total figure of merit
Return type:	float

gradient(params)¶

Calculate the total gradient.

Notes

Overrides AdjointMethod.gradient(…)

Parameters:	params (numpy.ndarray) – Design parameters with respect to which gradient is evaluated
Returns:	(Master node only) The gradient of total figure of merit.
Return type:	numpy.ndarray

update_system(params)¶: Update all of the individual AdjointMethods.

class emopt.adjoint_method.AdjointMethodPNF2D(sim, step=1e-08)¶

Bases: emopt.adjoint_method.AdjointMethodFM2D

Define an AdjointMethod object for a figure of merit which contains power normalization in 2D problems.

A power-normalized figure of merit has the form

\[F(\mathbf{E}, \mathbf{H}, \epsilon, \mu) = \frac{f(\mathbf{E}, \mathbf{H})} {P_\mathrm{src}(\mathbf{E}, \mathbf{H}, \epsilon, \mu)}\]

where \(\epsilon\) and \(\mu\) are the permittivity and permeability and \(f(...)\) is a figure of merit which depends only on the fields (e.g. power flowing through a plane, mode match, etc)

calc_dFdm(sim, params)¶

Calculate the derivative of the power-normalized figure of merit with respect to the permittivity and permeability.

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	(Master node only) The derivative of F with respect to \(\epsilon\), \(\epsilon^\), \(\mu\), and \(\mu^\)
Return type:	list of numpy.ndarray

calc_dFdx(sim, params)¶

Calculate the derivative of the power-normalized figure of merit with respect to the field.

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The derivative of F with respect to the fields in the form (E, H)
Return type:	tuple of numpy.ndarray

calc_dfdx(sim, params)¶

Calculate the derivative of the non-power-normalized figure of merit with respect to the fields in the discretized grid.

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The derivative of f with respect to the fields in the form (E, H)
Return type:	tuple of numpy.ndarray

calc_f(sim, params)¶

Calculate the non-power-normalized figure of merit \(f(\mathbf{E}, \mathbf{H})\).

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the non-power-normalized figure of merit.
Return type:	float

calc_fom(sim, params)¶

Calculate the power-normalized figure of merit.

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the power-normalized figure of merit.
Return type:	float

calc_penalty(sim, params)¶

Calculate the additive contribution to the figure of merit by explicit functions of the design variables.

Because of the power normalization, we have to handle contributions to the figure of merit which depend explicitly on the design variables separately. This function returns the value of the functional Q(p) where Q(p) is given by F = f(E,H,p)/Psrc + Q(p).

This is typically used to impose penalties to the figure of merit (hence the name of the function).

Parameters:	sim (emopt.fdfd.FDFD) – The FDFD simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the penalty function
Return type:	tuple of numpy.ndarray

class emopt.adjoint_method.AdjointMethodPNF3D(sim, step=1e-08)¶

Bases: emopt.adjoint_method.AdjointMethod

Define an AdjointMethod object for a figure of merit which contains power normalization in 3D problems.

In 3D, lossy materials are not supported. As a result, power normalization is based purely on the power flux at the boundaries of the simulation (and is thus independent of the material values within the simulation domain).

calc_dFdx(sim, params)¶

Calculate the derivative of the power-normalized figure of merit with respect to the field.

Parameters:	sim (emopt.simulation.MaxwellSolver) – The 3D simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The derivative of F with respect to the fields in the form (E, H)
Return type:	tuple of numpy.ndarray

calc_dfdx(sim, params)¶

Calculate the derivative of the non-power-normalized figure of merit with respect to the fields in the discretized grid.

Parameters:	sim (emopt.simulation.MaxwellSolver) – The 3D simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The derivative of f with respect to the fields in the form (E, H)
Return type:	list of tuples of 6 numpy.ndarray

calc_f(sim, params)¶

Calculate the non-power-normalized figure of merit \(f(\mathbf{E}, \mathbf{H})\).

Parameters:	sim (emopt.simulation.MaxwellSolver) – The 3D simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the non-power-normalized figure of merit.
Return type:	float

calc_fom(sim, params)¶

Calculate the power-normalized figure of merit.

Parameters:	sim (emopt.simulation.MaxwellSolver) – The 3D simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the power-normalized figure of merit.
Return type:	float

calc_penalty(sim, params)¶

Calculate the additive contribution to the figure of merit by explicit functions of the design variables.

Because of the power normalization, we have to handle contributions to the figure of merit which depend explicitly on the design variables separately. This function returns the value of the functional Q(p) where Q(p) is given by F = f(E,H,p)/Psrc + Q(p).

This is typically used to impose penalties to the figure of merit (hence the name of the function).

Parameters:	sim (emopt.simulation.MaxwellSolver) – The 3D simulation object. params (numpy.ndarray) – The current set of design variables
Returns:	The value of the penalty function
Return type:	tuple of numpy.ndarray

get_fom_domains()¶

Retrieve the user-defined domains where the figure of merit is calculated.

Returns:	The list of FOM domains.
Return type:	List of emopt.misc.DomainCoordinates