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).

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='schur') replaces the scipy.linalg.eig function by a schur decomposition followed by a diagonalisation of the schur matrix. While scipy.linalg.eig performs such a schur decomposition internally in any case, it seems that explicitly calling the schur decomposition beforehand improves the stability. Nevertheless to really solve the problem, the second method (diagonalization_method='schur_forcedtriu') consists in removing the 2x2 and 3x3 blocks from the schur matrix, i.e. forcing the schur 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 schur 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='schur_forcedtriu', diagonalization_cache=False, rayleigh_jeans_approximation=False)

Bases: RTSolverBase, CoherentLayerMixin, DiscreteOrdinatesMixin, PlanckMixin

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 “schur” replaces the scipy.linalg.eig function by a schur decomposition followed by a diagonalisation of the schur matrix. The “schur_forcedtriu” forces the schur 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.

• diagonalization_cache – If “simple”, cache the results of the diagonalization to avoid redundant computation. This can speed up significantly the computation when many layers have exactly the same scattering properties in a snowpack or across snowpacks of a sensitivity analysis where only one or few layers are changed at a time. The drawback is that it uses more memory as the simple cache is never emptied. LRU cache could be implemented in the future to limit memory usage while style keeping some efficiency. This feature is experimental, please report success and failure.

• rayleigh_jeans_approximation – In passive mode, if True, use the Rayleigh-Jeans approximation for the Planck function. This mode was used by default up to SMRT 1.5.1, but is not as precise as the full Planck function at higher frequencies and low temperatures.

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

compiled_todiag(bmat, oi, oj, dmat)

Insert a dense block dmat into a banded matrix representation bmat.

The function assumes bmat uses the (upper, lower) banded storage with center row at index u = (bmat.shape[0] - 1) // 2 and inserts the values of dmat at the appropriate diagonals given offsets oi and oj.

Parameters:

• bmat (ndarray) – Banded matrix storage array of shape (2*nband+1, nboundary).

• oi (int) – Row offset where the block should be placed.

• oj (int) – Column offset where the block should be placed.

• dmat (ndarray) – Dense matrix block to insert.

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. It provides efficient backscatter calculations but is limited to 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', rayleigh_jeans_approximation=False)

Bases: CoherentLayerMixin, DiscreteOrdinatesMixin, PlanckMixin, 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.

• rayleigh_jeans_approximation – In passive mode, if True, use the Rayleigh-Jeans approximation for the Planck function. This mode was used by default up to SMRT 1.5.1, but is not as precise as the full Planck function at higher frequencies and low temperatures.

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 refelction (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.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, numerical_convolution=False)

Bases: WaveformModel

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.

class Newkrik1992(sensor)

Bases: WaveformModel

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.