smrt.rtsolver package 

This package contains several solvers of the radiative transfer equation. Based on the electromagnetic properties of each layer computed by the EM model, these RT solvers compute the emission and propagation of energy in the medium up to the surface (the atmosphere is usually dealt with independently in dedicated modules in smrt.atmosphere).

The solvers differ by the approximations and numerical methods. dort is currently the most accurate and recommended in most cases unless the computation time is a constraint or for altimetric simulations.

Selection of the solver is done with the smrt.core.model.make_model function.

Here are some recommendations to choose an appropriate solver:

SMRT Solvers Overview
Solver Name	Description	Use Case	Performance
`dort`	The default original solver in SMRT for passive microwave (brightness temperature) and radar (sigma0). General and robust.	General applications for both passive microwave and radar.	Robust but slow
`iterative_first_order`	Radar-only solver using an iterative method up to first order. Fast and provides contributions of interaction mechanisms.	Radar studies, especially to analyze interaction mechanisms.	Fast
`successive_order`	Solver combining an iterative method and discrete ordinate to compute successive orders of interactions up to 50 by default or until a convergence is reached. It converges to numerical results close to dort.	Analysis of the dominant interaction mechanisms (it results orders separately). Alternative to dort, that can be much faster and more stable for shallow and weakly scattering snowpacks or when accuracy is not critical and truncation can be applied, but can also be much slower for optical thick snowpacks.	Speed is variable
`multifresnel_thermalemission`	Passive microwave-only solver assuming no scattering in the layers and flat interfaces.	Radiometry at low frequency when scattering is negligible.	Very fast
`nadir_lrm_altimetry`	Specialized solver for altimeter in Low Rate Mode. Solve the first order interaction.	Altimetry in Low Rate Mode (LRM).
`nadir_sar_altimetry`	Specialized solver for altimeter in SAR Mode. Solve the first order interaction.	Altimetry in Synthetic Aperture Radar (SAR).

For Developers

To experiment with DORT code, it is recommended to copy the file dort.py to e.g. dort_mytest.py so it is immediately available through smrt.core.model.make_model.

To develop a new solver that will be accessible by the smrt.core.model.make_model function, add a file in this directory. Refer to dort.py as an example. Only the solve method needs to be implemented. It must return a smrt.core.result.Result instance with the results. Contact the core developers for more details.

smrt.rtsolver.dort module 

Provide the Discrete Ordinate and Eigenvalue Solver as a multi-stream solver of the radiative transfer model in active and passive mode.

This solver is precise but less efficient than 2 or 6 flux solvers. Different flavours of DORT (or DISORT) exist in the literature depending on the mode (passive or active), the polarization capabilities, the density of the medium (sparse media have trivial inter-layer boundary conditions), on the way the streams are connected between the layers and on the way the phase function is prescribed. The actual version is a blend between Picard et al. 2004 (active mode for sparse media) and DMRT-ML (Picard et al. 2013) which works in passive mode only for snow. The DISORT often used in optics (Stamnes et al. 1988) only works for sparse medium and uses a development of the phase function in Legendre polynomials on theta. The version used in DMRT-QMS (L. Tsang’s group) is similar to the present implementation except it uses spline interpolation to connect constant-angle streams between the layers although we use direct connection by varying the angle according to Snell’s law. A practical consequence is that the number of streams vary (due to internal reflection) and the value n_max_stream only applies in the most refringent layer. The number of outgoing streams in the air is usually smaller, sometimes twice smaller (depends on the density profile). It is important not to set too low a value for n_max_stream. E.g. 32 is usually fine, 64 or 128 are better but simulations will be much slower.

Note

The DORT solver is very robust in passive mode but may raise exception in active mode due to a matrix diagonalisation problem. The exception provides detailed information on how to address this issue. Two new diagonalisation approaches were added in January 2024. They are activated by setting the diagonalization_method optional argument (see smrt.core.make_model). The first method (diagonalization_method='shur') replaces the scipy.linalg.eig function by a shur decomposition followed by a diagonalisation of the shur matrix. While scipy.linalg.eig performs such a shur decomposition internally in any case, it seems that explicitly calling the shur decomposition beforehand improves the stability. Nevertheless to really solve the problem, the second method (diagonalization_method='shur_forcedtriu') consists in removing the 2x2 and 3x3 blocks from the shur matrix, i.e. forcing the shur matrix to be upper triangular (triu in numpy jargon = zeroing the lower part of this matrix). This problem is due to the structure of the matrix to be diagonalized and the formulation of the DORT method in the polarimetric configuration. The eigenvalues come by triplets and can be very close to each other for the three H, V, U Stokes components when scattering is becoming small (or equiv. the azimuth mode ‘m’ is large). As a consequence of the Gershgorin theorem, this results in slightly complex eigenvalues (i.e. eigenvalues with very small imaginary part) that comes from 2x2 or 3x3 blocks in the shur decomposition. This would not be a problem if the eigenvectors were correctly estimated, but this is not the case. It is indeed difficult to find the correct orientation of eigenvectors associated to very close eigenvalues. To overcome the problem, the solution is to remove the 2x2 and 3x3 blocks. In principle, it would be safer to check that these blocks are nearly diagonal but this is not done in the current implementation. The user is responsible to switch between the options until it works. After sufficient successful reports by users are received the last method (forcedtriu) will certainly be the default.

Usage:

Basic usage with default settings and iba emmodel:

>>> m = make_model("iba", "dort")

Handle errors gracefully in batch processing:

>>> m = make_model("iba", "dort", rtsolver_options = {'error_handling':'nan'})

References

Picard, G., Le Toan, T., Quegan, S., Caraglio, Y., and Castel, T. (2004). Radiative Transfer Modeling of Cross-Polarized Backscatter From a Pine Forest Using the Discrete Ordinate and Eigenvalue Method. IEEE TRANSACTIONS ON GEOSCIENCE AND REMOTE SENSING, VOL. 42, NO. 8, https://doi.org/10.1109/TGRS.2004.831229
Picard, G., Brucker, L., Roy, A., Dupont, F., Fily, M., Royer, A., and Harlow, C. (2013) Simulation of the microwave emission of multi-layered snowpacks using the Dense Media Radiative transfer theory: the DMRT-ML model, Geosci. Model Dev., 6, 1061-1078, https://doi.org/10.5194/gmd-6-1061-2013
Stamnes, K., Tsay, S-C., Wiscombe, W., and Jayaweera, K. (1988). Numerically stable algorithm for discrete-ordinate-method radiative transfer in multiple scattering and emitting layered media. Applied Optics, 27-12, pp.2502-2509. https://doi.org/10.1364/AO.27.002502

class DORT(n_max_stream=32, m_max=2, stream_mode='most_refringent', phase_normalization='auto', phase_symmetrization=False, error_handling='exception', process_coherent_layers=False, prune_deep_snowpack=None, diagonalization_method='eig')

Bases: RTSolverBase, CoherentLayerMixin, DiscreteOrdinatesMixin

Implement the Discrete Ordinate and Eigenvalue Solver.

Parameters:

n_max_stream – number of stream in the most refringent layer.
m_max – number of mode (azimuth).
stream_mode – If set to “most_refringent” (the default) or “air”, streams are calculated using the Gauss-Legendre polynomials and then use Snell-law to prograpate the direction in the other layers. If set to “uniform_air”, streams are calculated uniformly in air and then according to Snells law.
phase_normalization – the integral of the phase matrix should in principe be equal to the scattering coefficient. However, some emmodels do not respect this strictly. In general a small difference is due to numerical rounding and is acceptable, but a large difference rather indicates either a bug in the emmodel or input parameters that breaks the assumption of the emmodel. The most typical case is when the grain size is too big compared to wavelength for emmodels that rely on Rayleigh assumption. If this argument is to True, the phase matrix is normalized to be coherent with the scattering coefficient, but only when the difference is moderate (0.7 to 1.3). If set to “forced” the normalization is always performed. This option is dangerous because it may hide bugs or unappropriate input parameters (typically too big grains). If set to False, no normalization is performed. If set to “auto” the normalization is performed except for emmodels not respecting the reciprocity princple (which the normalization relies on).
phase_symmetrization – enforce phase function symmetry by replacing the phase function P by (P + P.T)/2 (simplified).
error_handling – If set to “exception” (the default), raise an exception in case of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusuable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.
process_coherent_layers – Adapt the layers thiner than the wavelegnth using the MEMLS method. The radiative transfer theory is inadequate layers thiner than the wavelength and using DORT with thin layers is generally not recommended. In some parcticular cases (such as ice lenses) where the thin layer is isolated between large layers, it is possible to replace the thin layer by an equivalent reflective interface. This neglects scattering in the thin layer, which is acceptable in most case, because the layer is thin. To use this option and more generally to investigate ice lenses, it is recommended to read MEMLS documentation on this topic.
prune_deep_snowpack – this value is the optical depth from which the layers are discarded in the calculation. It is to be use to accelerate the calculations for deep snowpacks or at high frequencies when the contribution of the lowest layers is neglegible. The optical depth is a good criteria to determine this limit. A value of about 6 is recommended. Use with care, especially values lower than 6.
diagonalization_method – This value set the method for the diagonalization in the eigenvalue solver. The defaut is “eig”, it uses the scipy.linalg.eig function. The “shur” replaces the scipy.linalg.eig function by a shur decomposition followed by a diagonalisation of the shur matrix. The “shur_forcedtriu” forces the shur matrix to be upper triangular. The “half_rank_eig” is the fastest method but requires symmetry and energy conservation which may fail with some EMModels and for some parameters. The “stamnes88” is another half rank fast method.

solve(snowpack, emmodels, sensor, atmosphere=None)

Solve the radiative transfer equation for a given snowpack, emmodels and sensor configuration.

Parameters:

snowpack – Snowpack object.
emmodels – List of electromagnetic models object.
sensor – Sensor object.
atmosphere – [Optional] Atmosphere object.

Returns:

Result object.

Return type:

result

smrt.rtsolver.iterative_first_order module 

Provide the iterative first-order radiative transfer solver.

This module implements a first-order iterative solution for the radiative transfer equation to calculate backscatter coefficients. The solver computes both zeroth and first-order backscatter contributions and is computationally more efficient than the DORT solver, but should be used with caution.

Key Features:

Separate different backscatter mechanisms for analysis.
More computationally efficient than full DORT solver.
Provide diagnostic information about scattering contributions.

Backscatter Components:

Zeroth Order:

order0_backscatter: Backscatter from the surface, interfaces, and substrate after attenuation through the snowpack. Volume Scattering is only included through its contribution to extinction. (Reference: Ulaby et al. 2014, first term of Eq. 11.74)

First Order:

Calculate three main contributions (Ulaby et al. 2014, Eqs. 11.75 and 11.62):

order1_direct_backscatter: Single volume backscatter upwards by the layer.
order1_double_bounce: Single volume scattering and single reflection by the interfaces and the substrate.
order1_reflected_backscatter: Single volume backscatter and double specular reflection by the interfaces and the substrate.

Usage:

Basic usage with default settings and iba emmodel:

>>> m = make_model("iba", "iterative_first_order")

Return individual contributions for analysis:

>>> m = make_model("iba", "iterative_first_order", rtsolver_options= {'return_contributions' : True})

Handle errors gracefully in batch processing:

>>> m = make_model("iba", "iterative_first_order", rtsolver_options = {'error_handling':'nan'}

Note

This solver is designed for backscatter calculations only.
Single scattering albedo should be < 0.5 for reliable results. Can compare to dort to estimate unaccounted scattering.
Multiple scattering effects are not accounted for in first-order approximation.
For higher scattering albedos, a second-order solution is required.

References

Ulaby, F. T., et al. (2014). Microwave radar and radiometric remote sensing. Chapter 11.
Tsang, L., Pan, J., Liang, D., Li, Z., Cline, D. W., & Tan, Y. (2007). Modeling Active Microwave Remote Sensing of Snow Using Dense Media Radiative Transfer (DMRT) Theory With Multiple-Scattering Effects. IEEE Transactions on Geoscience and Remote Sensing, 45(4), 990–1004. https://doi.org/10.1109/tgrs.2006.888854
Tan, S., Chang, W., Tsang, L., Lemmetyinen, J., & Proksch, M. (2015). Modeling Both Active and Passive Microwave Remote Sensing of Snow Using Dense Media Radiative Transfer (DMRT) Theory With Multiple Scattering and Backscattering Enhancement. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 8(9), 4418–4430. https://doi.org/10.1109/jstars.2015.2469290

class IterativeFirstOrder(error_handling='exception', return_contributions=False)

Bases: RTSolverBase

Implement the iterative radiative transfer solver using first-order approximation.

This solver computes the zeroth- and first-order terms of the iterative solution for the radiative transfer equation and provides efficient backscatter calculations for scenarios with relatively low scattering albedos.

Parameters:

error_handling – If set to “exception” (the default), raise an exception in case of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusuable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.
return_contributions –
If False (default), returns only total backscatter. If True, returns individual contributions: - ‘total’: Sum of all contributions. - ‘order0_backscatter’: Backscatter from the surface, interfaces, and substrate after attenuation

through the snowpack.
- ’order1_direct_backscatter’: Single volume backscatter upwards by the layer.
- ’order1_double_bounce’: Single volume scattering and single reflection by the interfaces and the
  substrate.
- ’order1_reflected_backscatter’: Single volume backscatter and double specular reflection by the
  interfaces and the substrate.

solve(snowpack, emmodels, sensor, atmosphere=None)

Solve the radiative transfer equation for a given snowpack, emmodels and sensor configuration.

Parameters:

snowpack – Snowpack object.
emmodels – List of electromagnetic models object.
sensor – Sensor object.
atmosphere – [Optional] Atmosphere object.

Returns:

Result object.

Return type:

result

smrt.rtsolver.successive_order module 

Provide the Successive Order Solver as a multi-stream solver of the radiative transfer model based on Lenoble et al. 2007 and Greenwald et al. 2005, with some adaptation using SMRT DORT code.

The main interests of this solver are:

to provide the succesive orders of interaction separately, allowing the investigation of the interaction mechanisms.
faster computations in some conditions: The favorable conditions for fast computation: 1) shallow snowpack, 2) small grains / weak scattering (i.e. small optical depth), 3) truncation of the computation at low orders. Benchmarking is necessary as DORT can also be orders of magnitude faster for thick snowpacks with big grains.
an alternative to DORT when it fails due to eigenvalue solution and grains are not very big (scattering is small).

Basic usage with default settings and iba emmodel:

>>> m = make_model("iba", "successing_order")

References

Lenoble, J., Herman, M., Deuzé, J. L., Lafrance, B., Santer, R., & Tanré, D. (2007). A successive order of scattering code for solving the vector equation of transfer in the earth’s atmosphere with aerosols. Journal of Quantitative Spectroscopy and Radiative Transfer, 107(3), 479–507. https://doi.org/10.1016/j.jqsrt.2007.03.010

Greenwald, T., Bennartz, R., O’Dell, C., & Heidinger, A. (2005). Fast Computation of Microwave Radiances for Data Assimilation Using the “Successive Order of Scattering” Method. Journal of Applied Meteorology, 44(6), 960–966. https://doi.org/10.1175/jam2239.1

Heidinger, A. K., O’Dell, C., Bennartz, R., & Greenwald, T. (2006). The Successive-Order-of-Interaction Radiative Transfer Model. Part I: Model Development. Journal of Applied Meteorology and Climatology, 45(10), 1388–1402. https://doi.org/10.1175/jam2387.1

class SuccessiveOrder(n_max_stream=32, n_iteration_max=50, relative_tolerance=0.001, m_max=2, stream_mode='most_refringent', phase_symmetrization=False, error_handling='exception', process_coherent_layers=False, incident_polarizations='VH')

Bases: CoherentLayerMixin, DiscreteOrdinatesMixin, RTSolverBase

Implement the Successive Order solver.

Parameters:

n_iteration_max – maximum number of computed orders. Setting a value of e.g. 2 only computes first and second order scattering. The first order includes only one volume scattering event or one interface reflection. Second order includes two volume scattering events, two interface reflections, or one of each.
relative_tolerance – stop iterating when order[n] = relative_tolerance * order[0].
n_max_stream – number of stream in the most refringent layer.
m_max – number of mode (azimuth).
stream_mode – If set to “most_refringent” (the default) or “air”, streams are calculated using the Gauss-Legendre polynomials and then use Snell-law to prograpate the direction in the other layers. If set to “uniform_air”, streams are calculated uniformly in air and then according to Snells law.
phase_symmetrization – enforce phase function symmetry by replacing the phase function P by (P + P.T)/2 (simplified).
error_handling – If set to “exception” (the default), raise an exception in case of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusuable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.
process_coherent_layers – Adapt the layers thiner than the wavelegnth using the MEMLS method. The radiative transfer theory is inadequate layers thiner than the wavelength and using DORT with thin layers is generally not recommended. In some parcticular cases (such as ice lenses) where the thin layer is isolated between large layers, it is possible to replace the thin layer by an equivalent reflective interface. This neglects scattering in the thin layer, which is acceptable in most case, because the layer is thin. To use this option and more generally to investigate ice lenses, it is recommended to read MEMLS documentation on this topic.

solve(snowpack, emmodels, sensor, atmosphere=None)

Solve the radiative transfer equation for a given snowpack, emmodels and sensor configuration.

Parameters:

snowpack – Snowpack object, smrt.core.snowpack.
emmodels – List of electromagnetic models object, smrt.emmodel.
sensor – Sensor object, smrt.core.sensor.
atmosphere – [Optional] Atmosphere object, smrt.atmosphere.

Returns:

Result object, smrt.core.result.Result.

Return type:

result

prepare_snowpack_properties(m_max): Args:

smrt.rtsolver.multifresnel_thermalemission module 

Provide the Multi-Fresnel Thermal Emission (MFTE) RT solver for passive sensor.

Multi-Fresnel Thermal Emission (MFTE) is a fast RT solver suitable for passive microwave and none scattering media. It computes the thermal emission of a multi-layer stack of homogeneous layers (absorption only, no scattering) with flat interfaces (no roughness) solely characterized by their permittivity and temperature. It is most suitable for instance for L-band and lower frequencies over the dry zone of the ice-sheet where the penetration is deep and the stratification of the snowpack and the profile of temperature are crucial to compute the emission. Note that the layers are incoherent, layer thickness smaller than the wavelength are not recommended (at least not smaller than a quarter of the wavelength). In principle, MFTE gives the same results as DORT, when the aforementioned assumption are respected, but much more rapidely.

Even with a small number of layers, MFTE is x30 faster than DORT, and requires much less memory. The performance difference increases with the number of layers.

The model is inspired from:

Hébert, M., Simonot, L., & Mazauric, S. (2015). Matrix method to predict the spectral reflectance of stratified surfaces including thick layers and thin films. https://hal.science/hal-01155614

The formulation (with typos) is in the Annex:

P. Zeiger, G. Picard, P. Richaume, A. Mialon, Nemesio Rodriguez-Fernandez. Resolution enhancement of SMOS brightness temperatures: application to melt detection on the Antarctic and Greenland ice sheets, Remote Sensing of Environment, 315, 114469, http://doi.org/10.1016/j.rse.2024.114469, 2024

Usage:

# Create a model using a nonscattering medium and the rtsolver 'multifresnel_thermalemission'.
m = make_model("nonscattering", "multifresnel_thermalemission")

class MultiFresnelThermalEmission(error_handling: str = 'exception', prune_deep_snowpack: int = 10)

Bases: object

Implement the Multi-Fresnel Thermal Emission (MFTE) solver for SMRT.

Parameters:

error_handling – If set to “exception” (the default), raise an exception in cause of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusuable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.
prune_deep_snowpack – this value is the optical depth from which the layers are discarded in the calculation. This prevents numerical unstability inherent to the MFTE formulation for a very deep snowpack. A value of 10 is used by default which is already very large / safe. In case of problems of stability, this value should be decreased. Set to None to deactivate pruning, but this is not recommended.

solve(snowpack, emmodels, sensor, atmosphere=None)

Solve the radiative transfer equation for a given snowpack, emmodels and sensor configuration.

Parameters:

snowpack – Snowpack object.
emmodels – List of electromagnetic models object. With MFTE it is recommended to use the nonscattering emmodel even though other emmodels will work with their scattering not used.
sensor – Sensor object.
atmosphere – [Optional] Atmosphere object.

Returns:

Result object.

Return type:

result

smrt.rtsolver.nadir_lrm_altimetry module 

Compute waveforms as measured by Low Rate Mode altimeters (e.g. ENVISAT) for the given snowpack and sensor (or complex terrain soon).

The implementation is based on Adams and Brown 1998 and Lacroix et al. 2008. Both models differ in the specific choices for the scattering and backscatter of the interface, but are similar in the way the waveform is calculated, which concerns the solver here.

Approximations:

Backscatter is computed assuming only first order scattering. The propagation is then simply governed by extinction.
Near nadir / small angle approximation: to compute delay, the paths in the snow are along the z-axis. Off-nadir delay is neglected. This error is likely to be small (except for very deep penetration).
Do not account for specular reflection (to be implemented).

Note

With this RT solver, if using Geometrical Optics for rough surface/interface modeling, it is strongly advised to use smrt.interface.geometrical_optics_backscatter() instead of smrt.interface.geometrical_optics() for the reason explained in the documentation of those modules.

Usage:

Basic usage with default settings and iba emmodel:

>>> altimodel = make_model('iba', "nadir_lrm_altimetry")

Return individual contributions:

>>> altimodel = make_model('iba', "nadir_lrm_altimetry", rtsolver_options={return_contributions=True})

References

F. Larue, G. Picard, J. Aublanc, L. Arnaud, A. Robledano-Perez, E. Le Meur, V. Favier, B. Jourdain, J. Savarino, P. Thibaut, Radar altimeter waveform simulations in Antarctica with the Snow Microwave Radiative Transfer Model (SMRT) , Remote Sensing of Environment, 263, 112534 doi:10.1016/j.rse.2021.112534, 2021

class NadirLRMAltimetry(waveform_model=None, oversampling_time=10, return_oversampled=False, skip_pfs_convolution=False, return_contributions=False, compute_coherent_reflection=True, theta_inc_sampling=8, error_handling='exception')

Bases: object

Implement the Nadir LRM Mode Altimetry RT solver.

Parameters:

oversampling_time – integer number defining the number of subgates used for the computation in each altimeter gate. This is equivalent to multiply the bandwidth by this number. It is used to perform more accurate computation.
return_oversampled – by default the backscatter is returned for each gate. If set to True, the oversampled waveform is returned instead. See the ‘oversampling’ argument.
return_contributions – return “volume”, “surface” and “interface” backscatter contributions in addition to the “total” backscatter.
compute_coherent_reflection – if True (default), compute the coherent reflection according to Fung and Eom, 1983.
skip_pfs_convolution – return the vertical backscatter without the convolution by the PFS, if set to True.
theta_inc_sampling – number of subdivisions used to calculate the incidence angular variations of surface and inteface backscatter (the higher the better but the more computationnaly expensive). Note that the subdivisions are irregular in incidence angle but correspond to annulii of equi-duration. This number must be a true divider of the number of gates.
error_handling – If set to “exception” (the default), raise an exception in case of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusuable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.

solve(snowpack, emmodels, sensor, atmosphere=None)

Solve the radiative transfer equation for a given snowpack, emmodels and sensor configuration.

Parameters:

snowpack – Snowpack object.
emmodels – List of electromagnetic models object.
sensor – Sensor object.
atmosphere – [Optional] Atmosphere object.

Returns:

Result object.

Return type:

result

coherent_reflection_factor(sensor, roughness_rms, mu): return the factor to account for the coherent echo due to the spherical wave (see Fung and Eom, 1983) equation 6. This neglects the macroscopic slope of the terrain, which should be included in principle.

local_incidence_cosine(sensor, mu)

compute the cosine of the local incidence angle considering a small pitch and roll.

This function assumes pitch and roll are small, otherwise yaw would be involved in the equation

smrt.rtsolver.lrm_waveform_model module 

Provide Waveform models use in py:mod:smrt.rtsolver.nadir_lrm_altimetry.

Brown1977:

Brown, G. (1977).The average impulse response of a rough surface and its applications. IEEE Transactions on Antennas and Propagation. 25-1. pp.67-74. https://doi.org/10.1109/TAP.1977.1141536

Newkirk1992:

Newkirk, M.H., Brown, G.S., 1992. Issues related to waveform computations for radar altimeter applications. IEEE Trans. Antennas Propag. 40, 1478–1488. https://doi.org/10.1109/8.204738.

class Brown1977(sensor, pulse_sigma=None, numerical_convolution=False)

Bases: LRMWaveformModel

Implement the Antenna Gain formulation used by Brown 1977.

The formula is (exp left(frac{2}{gamma} sin^2 theta right) ) for the perfect nadir case, but is also available with off-nadir angles.

Parameters:

sensor – Sensor object.
numerical_convolution – Whether to use numerical convolution.
pulse_sigma – Standard deviation of the radar pulse in seconds. If None, it is set to 0.513 / pulse_bandwidth.

class Newkrik1992(sensor)

Bases: LRMWaveformModel

Implement the Antenna Gain formulation proposed by Newkrik and Brown, 1992.

Compared to the classical Brown 1977, it takes into account the asymmetry of the antenna pattern in the co and cross-track direction.

Parameters:: sensor – Sensor object.

smrt.rtsolver.nadir_sar_altimetry module 

This module provides Nadir SAR Mode Altimetry rtsolver.

This rtsolver computes delay Doppler maps and waveforms for the given snowpack and sensor (or complex terrain soon) according to a delay doppler model specified as input (and available in the directory smrt/rtsolver/delay_doppler_model). As opposed to other common rtsolvers in SMRT that behave independently, this solver delegates part of the computation to the selected delay doppler model. The results and the capabilities highly depend on the selected delay doppler model. For instance some delay doppler models can handle satellite mis-pointing, asymmetric antenna and/or Digital Elevation Model. Some models can compute delay Doppler maps without the slant range correction. Moreover they differ in many computational aspects that need to be understood before selecting one or another.

More precisely this rtsolver first computes the first-order backscatter coming for each “level”, including the surface, each interface, and the volume split in subgate intervals. In a second step it leverages the delay doppler model to compute how each level contributes to the delay Doppler map. It then sums all these contributions to get the final delay Doppler map and are returned as the AltimeterResult object. Ultimately, the waveform (= the sum in the Doppler dimension) can be obtained from this object. It is also possible to get the contributions from the surface, interfaces and volume independently (that is three different delay Doppler maps).

Main approximations:

Backscatter is computed assuming only first order scattering. The propagation is then simply calculated with the extinction.
Small-angle approximation: to compute delay, the paths in the snow are assumed vertical. We neglect the 1/cos(theta) lengthening of the path

Usage:

Basic usage with default settings and IBA EM model and Dinardo18 DDM model:

>>> m = make_model("iba", "nadir_sarm_altimetry", rtsolver_options = dict(delay_doppler_model="dinardo18"))

or using make_rtsolver:

>>> m = make_model("iba", make_rtsolver("nadir_sarm_altimetry",
                                        delay_doppler_model="dinardo18"))

To specifiy DDM settings, for instance to use Ray15 DDM model with specific PTRs:

>>> ddm_options = dict(ptr_time="gaussian", ptr_doppler="gaussian-smrt", slant_range_correction=True)
>>> m = make_model("iba", "nadir_sarm_altimetry",
                    rtsolver_options = dict(delay_doppler_model="ray15",
                                            delay_doppler_model_options=ddm_options))

An alternative using make_rtsolver:

>>> ddm_options = dict(ptr_time="gaussian", ptr_doppler="gaussian-smrt", slant_range_correction=True)
>>> m = make_model("iba", make_rtsolver("nadir_sarm_altimetry",
                                        delay_doppler_model=delay_doppler_model,
                                        delay_doppler_model_options=ddm_options))

References

Picard, G., Murfit, J., Zakharova, E., Zeiger, P., Arnaud, L., Aublanc, J., Landy, J., Scagliola, M., and Duguay, C. (2025). Simulating SAR altimeter echoes from cryospheric surfaces with the Snow Microwave Radiative Transfer (SMRT) model version sarm-v0. Geosci. Model Dev. Discuss., submitted.
Larue, F., Picard, G., Aublanc, J., Arnaud, L., Robledano-Perez, A., Meur, E. L., Favier, V., Jourdain, B., Savarino, J., & Thibaut, P. (2021). Radar altimeter waveform simulations in Antarctica with the Snow Microwave Radiative Transfer Model (SMRT). Remote Sensing of Environment, 263, 112534. https://doi.org/10.1016/j.rse.2021.112534

class NadirSARAltimetry(delay_doppler_model=None, delay_doppler_model_options={}, oversampling_time=4, oversampling_doppler=4, return_oversampled=False, skip_convolutions=False, return_contributions=False, theta_inc_sampling=8, error_handling='exception', prune_deep_snowpack=True)

Bases: object

RTSolver to calculate Delay Doppler Maps and waveforms in the SAR mode (InSAR and fully focused are not: implemented yet) by including backscatter of the surface, interfaces and volume.

Parameters:

delay_doppler_model – model (string or class) to use to compute the delay_doppler_map for an interface.
delay_doppler_model_options – options to apply to instantiate the delay_doppler_map model. The available options may be different for each model. Refer to the documentation of each model. The options slant_range_correction, ptr_time and ptr_doppler are often available.
oversampling_time – integer number defining the number of subgates used for the computation in each altimeter gate. This is equivalent to multiply the bandwidth by this number. It is used/necessary to perform more accurate computation.
oversampling_doppler – integer number defining the number of sub-Doppler beams used for the computation. This is equivalent to multiply the bandwidth by this number. It is used/necessary to perform more accurate computation.
return_oversampled – by default the backscatter is returned for each gate. If set to True, the oversampled waveform is returned instead. See the ‘oversampling’ argument.
return_contributions – controls the returned contributions as follows: - False or “no”: total backscatter only. - True or “basic”: total, volume, surface and interface backscatter. - “basic coherent”: total, volume, incoherent surface, coherent surface, incoherent interface, and coherent interface backscatter contributions. - “full”: total, volume, and all interfaces separated. - “full coherent”: total, volume, and all interface separated split into the coherent and incoherent components.
skip_convolutions – return the vertical backscatter without the convolution by the PFS, PTR_time, and PTR_doppler, if set to True.
theta_inc_sampling – number of subdivisions used to calculate the incidence angular variations of surface and interface backscatter (the higher the better but the more computationally expensive).
error_handling – If set to “exception” (the default), raise an exception in case of error, stopping the code. If set to “nan”, return a nan, so the calculation can continue, but the result is of course unusable and the error message is not accessible. This is only recommended for long simulations that sometimes produce an error.

solve(snowpack_or_terrain, emmodels, sensor, atmosphere=None): Solve the radiative transfer equation for a given snowpack (or terrain with multiple snowpack), emmodels and sensor configuration.

gate_depth(): Return gate depths that cover the snowpack for regular time sampling.

vertical_scattering_distribution(mu_i): Compute the vertical backscattering distribution due to “grain” or volume scattering, “interfaces” or ‘surface’ scattering

delay_doppler_model(model: str | Type, **options) → Type: Return a delay_doppler_model class based on its name, eventually specializing it if options are provided.

coherent_reflection_factor(sensor, roughness_rms, mu)

Return the factor for the coherent echo due to the spherical wave.

See Fung and Eom (1983), equation 6. This neglects the macroscopic slope of the terrain, which should be included in principle.

local_incidence_cosine(sensor, mu)

Compute the cosine of the local incidence angle considering small pitch and roll.

This function assumes pitch and roll are small; otherwise yaw would be involved in the equation.

smrt.rtsolver.delay_doppler_model.boy17 module 

This module calculates Delay Doppler Maps (DDM) following ideas in Boy et al. 2017, with some interpretation as the equations are not all explicited in the original paper.

The base idea of this model is to compute the FSSR as directly as possible from a x,y grid with 5 m resolution encompassing the whole footprint.

The antenna footprint expression in x,y coordinates is taken from Buchhaupt et al.2018. The footprint center is not at the center of the grid if the satellite is mis-pointing.

References

Boy, F., Desjonqueres, J.-D., Picot, N., Moreau, T., & Raynal, M. (2017). CryoSat-2 SAR-Mode Over Oceans: Processing Methods, Global Assessment, and Benefits. IEEE Transactions on Geoscience and Remote Sensing, 55(1), 148–158. https://doi.org/10.1109/tgrs.2016.2601958

class Boy17(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, ptr_time: str | None = None, ptr_doppler: str | None = None, slant_range_correction: bool = True, delay_window_widening: int = 1, grid_space: float = 5, with_earth_curvature: bool = True)

Bases: object

Build a Boy17 Delay Doppler Model.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in doppler dimension.
slant_range_correction – whether to apply the slant range correction (True=SAR mode, False=pseudo-LRM mode)
delay_window_widening – factor to widen the delay window. The default (1) is relevant when comparing with observed waveforms.
grid_space – spatial resolution of the x,y grid (in meters).
with_earth_curvature – whether to consider earth curvature.

delay_doppler_map_with_sigma0func(terrain_info: TerrainInfo, sigma0: _Buffer | _SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes] = 1): Compute the delay doppler map for a surface

impulse_map(gate, doppler_bin, grid_extent, terrain_info: TerrainInfo)

Compute the map of the impulse function for a given gate and doppler_bin.

This map indicates the area “seen” for this gate and doppler_bin.

Parameters:

gate – gate number (0 correspond to the nadir, the nominal_gate is not taken into account).
doppler_bin – doppler bin.
grid_extent – size of the grid to return (in meter).

smrt.rtsolver.delay_doppler_model.buchhaupt18 module 

This module calculates Delay Doppler Maps based on Buchhaupt et al. 2018.

It assumes that the PTRx and PTRdoppler are sinc**2. Can be easily changed if the PTRs have a known Fourier Transform

References

Buchhaupt, C., Fenoglio-Marc, L., Dinardo, S., Scharroo, R., & Becker, M. (2018). A fast convolution based waveform model for conventional and unfocused SAR altimetry. Advances in Space Research, 62(6), 1445–1463. https://doi.org/10.1016/j.asr.2017.11.039

class Buchhaupt18(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, ptr_time: str | None = None, ptr_doppler: str | None = None, slant_range_correction: bool | str = True, delay_window_widening: int = 1)

Bases: object

Build a Buchhaupt18 Delay Doppler Model.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in doppler dimension.
slant_range_correction – whether to apply slant_range or not, and if yes how. This module can performed “analytical” slant range correction applying the correction in the time delay calculation. In contrast “numerical” is closer to SAR processing and to real observations, the DDM is first calculated without correction, and migration is then applied on the DDM. If set to True, “numerical” is used if the widening factor is <= 1, otherwise “analytical” is used.
delay_window_widening – factor to widen the delay window. The default (1) is relevant when comparing with observed waveforms.

delay_doppler_map_with_GO(terrain_info: TerrainInfo, mean_square_slope: _Buffer | _SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes] = inf): Compute the delay doppler map for a surface.

smrt.rtsolver.delay_doppler_model.dinardo18 module 

This module calculates Delay Doppler Map (DDM) based on Dinardo et al. 2018.

This DDM model extends Ray et al. 2015 with a fully analytical solution under the conditions that the surface is Gaussian and the backscatter decreases according to Geometrical Optics, using analytical functions.

References

Dinardo, S., Fenoglio-Marc, L., Buchhaupt, C., Becker, M., Scharroo, R., Joana Fernandes, M., & Benveniste, J. (2018). Coastal SAR and PLRM altimetry in German Bight and West Baltic Sea. Advances in Space Research, 62(6), 1371–1404. https://doi.org/10.1016/j.asr.2017.12.018
Ray, C., Martin-Puig, C., Clarizia, M. P., Ruffini, G., Dinardo, S., Gommenginger, C., & Benveniste, J. (2015). SAR Altimeter Backscattered Waveform Model. IEEE Transactions on Geoscience and Remote Sensing, 53(2), 911–919. https://doi.org/10.1109/tgrs.2014.2330423

class Dinardo18(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, ptr_time: str | None = None, ptr_doppler: str = 'gaussian-smrt')

Bases: object

Build a delay Doppler map model Dinardo18.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in Doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in Doppler dimension.

delay_doppler_map_with_GO(terrain_info: TerrainInfo, mean_square_slope: _Buffer | _SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | bool | int | float | complex | str | bytes | _NestedSequence[bool | int | float | complex | str | bytes] = inf): Compute the delay doppler map for a surface

smrt.rtsolver.delay_doppler_model.halimi14 module 

This module calculates Delay Doppler Map (DDM) based on Halimi et al. 2014.

This DDM model is a semi-analytical method where the FSIR is calculated with an integral and the PTRf and PTRt convolution are performed using numerical convolution.

The antenna footprint is circular and mispointing is not an option.

References

Halimi, A., Mailhes, C., Tourneret, J.-Y., Thibaut, P., & Boy, F. (2014). A Semi-Analytical Model for Delay/Doppler Altimetry and Its Estimation Algorithm. IEEE Transactions on Geoscience and Remote Sensing, 52(7), 4248–4258. https://doi.org/10.1109/tgrs.2013.2280595

class Halimi14(sensor, oversampling_time: int = 4, oversampling_doppler: int = 64, ptr_time: str | None = None, ptr_doppler: str | None = None, slant_range_correction: bool = True, delay_window_widening: int = 1)

Bases: object

Build a delay Doppler map model Halimi14.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in Doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in Doppler dimension.
slant_range_correction – whether to apply the slant range correction (True=SAR mode, False=pseudo-LRM mode).
delay_window_widening – factor to widen the delay window. The default (1) is relevant when comparing with observed waveforms.

delay_doppler_map(terrain_info: TerrainInfo): Compute the delay Doppler map for a surface.

smrt.rtsolver.delay_doppler_model.landy19 module 

smrt.rtsolver.delay_doppler_model.ray15 module 

This module calculates Delay Doppler Maps (DDM) based on Ray et al. 2015 with a semi-analytical solution.

References

Ray, C., Martin-Puig, C., Clarizia, M. P., Ruffini, G., Dinardo, S., Gommenginger, C., & Benveniste, J. (2015). SAR Altimeter Backscattered Waveform Model. IEEE Transactions on Geoscience and Remote Sensing, 53(2), 911–919. https://doi.org/10.1109/tgrs.2014.2330423

class Ray15(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, ptr_time: str = 'gaussian', ptr_doppler: str = 'gaussian-smrt')

Bases: object

Build a delay Doppler map model Ray15.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in Doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in Doppler dimension.

delay_doppler_map(terrain_info: TerrainInfo)

Compute the delay Doppler map for a surface.

Note that Ray 2015 is formulated for a free function but is implemented for a constant backscatter only to cope with the optimization with numba.

smrt.rtsolver.delay_doppler_model.wingham04 module 

This module calculates Delay Doppler Maps (DDM) based on Wingham et al. 2004.

The slant range correction as described by Wingham et al. 2004 is not implemented here; instead we use the numerical correction (in .delay_compensation) applied directly on the delay Doppler map.

References

D. J. Wingham, L. Phalippou, C. Mavrocordatos and D. Wallis, “The mean echo and echo cross product from a beamforming interferometric altimeter and their application to elevation measurement,” in IEEE Transactions on Geoscience and Remote Sensing, vol. 42, no. 10, pp. 2305-2323, Oct. 2004, doi: 10.1109/TGRS.2004.834352.

class Wingham04(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, ptr_tau: str | None = None, ptr_fdoppler: str | None = None, slant_range_correction: bool = True, delay_window_widening: int = 1)

Bases: object

Build a delay Doppler map model Wingham04.

Parameters:

sensor – SAR altimetry sensor object.
oversampling_time – oversampling factor in time dimension.
oversampling_doppler – oversampling factor in Doppler dimension.
ptr_time – shape of the point target response in time dimension.
ptr_doppler – shape of the point target response in Doppler dimension.
slant_range_correction – whether to apply the slant range correction (True=SAR mode, False=pseudo-LRM mode)
delay_window_widening – factor to widen the delay window. The default (1) is relevant when comparing with observed waveforms.

delay_doppler_map(terrain_info: TerrainInfo): Compute the delay Doppler map for a surface.

impulse_map(grid_extent, terrain_info: TerrainInfo, gate=None, doppler_bin=None)

Compute the map of the impulse function for a given gate and doppler_bin.

Parameters:

grid_extent – size of the grid to return (in meters).
terrain_info – terrain information used by the model.
gate – gate number (0 corresponds to nadir; nominal_gate is not taken into account).
doppler_bin – Doppler bin index.

This map indicates the area “seen” for this gate and doppler_bin.

smrt.rtsolver.delay_doppler_model.wingham18 module 

This module calculates Delay Doppler Maps (DDM) based on Wingham et al. 2018.

References

D. J. Wingham, K. A. Giles, N. Galin, R. Cullen, T. W. K. Armitage and W. H. F. Smith, “A Semianalytical Model of the Synthetic Aperture, Interferometric Radar Altimeter Mean Echo, and Echo Cross-Product and Its Statistical Fluctuations,” in IEEE Transactions on Geoscience and Remote Sensing, vol. 56, no. 5, pp. 2539-2553, May 18, doi: 10.1109/TGRS.2017.2756854.

class Wingham18(sensor, oversampling_time: int = 4, oversampling_doppler: int = 4, slant_range_correction: bool | str = True, ptr_time: str | None = None, ptr_doppler: str | None = None, delay_window_widening: int = 1)

Bases: object

Build a delay Doppler map model Wingham18.

Parameters:

sensor – SAR altimetric sensor oversampling_time: oversampling factor in time dimension.
oversampling_doppler – oversampling factor in doppler dimension.
slant_range_correction – whether to apply slant_range or not, and if yes how. This module can performed “analytical” slant range correction applying the correction in the time delay calculation. In contrast “numerical” is closer to SAR processing and to real observations, the DDM is first calculated without correction, and migration is then applied on the DDM. If set to True, “numerical” is used if the widening factor is <= 1, otherwise “analytical” is used.
ptr_time – shape of the PTR_time function.
ptr_doppler – shape of the PTR_doppler function.
delay_window_widening – factor controlling the number of gates used to compute the DDM before the slant range correction. Defaults to 1. See the slant_range_correction attribute.

delay_doppler_map(terrain_info: TerrainInfo): Compute the delay doppler map for a surface

get_j_integrand(j: int)

Return the integrand in j function defined in W18 Eq 14.

For efficiency reason they are return as compiled C function (more precisely scipy.LowLevelCallable) suitable for the integration with scipy.integrate.quad. To avoid the cost of mulitple compilations, the result is cached. Changing the sensor, the kernel or the ptr_doppler