smrt.inputs package

This package includes modules to create the medium and sensor configuration required for the simulations. The recommended way to build these objects:

from smrt import make_snowpack, sensor_list

sp = make_snowpack([1000], density=[300], microstructure_model='sticky_hard_spheres', radius=[0.3e-3], stickiness=0.2)

radiometer = sensor_list.amsre()

Note that the function make_snowpack() and the module sensor_list is directly imported from smrt, which is convenient but they effectively lie in the package smrt.inputs. They could be imported using the full path as follows:

from smrt.inputs.make_medium import make_snowpack
from smrt.inputs import sensor_list

sp = make_snowpack([1000], density=[300], microstructure_model='sticky_hard_spheres', radius=[0.3e-3], stickiness=0.2)

radiometer = sensor_list.amsre()

Extension of the modules in the inputs package is welcome. This is as simple as adding new functions in the modules (e.g. in sensor_list) or adding a new modules (e.g. my_make_medium.py) in this package and use the full path import.

smrt.inputs.make_medium module

Provide helper functions to create snowpacks, sea-ice, and other media. These functions are user-friendly and recommended for most usages. Extension of these functions is welcome on the condition they keep a generic structure.

The function make_snowpack is the first entry point the user should consider to build a snowpack.

Example:

from smrt import make_snowpack

sp = make_snowpack([1000], density=[300], microstructure_model='sticky_hard_spheres', radius=[0.3e-3], stickiness=0.2)

Create a semi-infinite snowpack made of sticky hard spheres with radius 0.3mm and stickiness 0.2. The Snowpack object is in the sp variable.

Note

Any layer with zero thickness is completely removed in most of these functions (as well as its top interface), and a transparent layer is added if the resulting medium does not have any layer. This allows simulation of bare soil and bare ice more easily. It is important to understand that any layer with non-zero thickness, even much smaller than the wavelength, even 10 -20 m, has an impact in the radiative transfer framework due to the reflection, transmission and refraction. In reality, and according to the wave theory such sub-wavelength layers and their interface should have reduced or close to zero impact. It is the responsibility of the user to ensure that such thin layers (less than a quarter of wavelength) are removed from the snowpack. Alternatively, setting the process_coherent_layers option when using the smrt.rtsolver.dort solver allows to deal with sub-wavelength layers provided they are isolated between two thick layers.

Note that make_snowpack is directly imported from smrt instead of smrt.inputs.make_medium. This feature is for convenience.

make_medium(data, surface=None, interface=None, substrate=None, **kwargs)

Build a multi-layered medium using a pandas DataFrame (or a dict that can be transformed into a DataFrame) and optional arguments.

The ‘medium’ column (or key) in data indicates the medium type: ‘snow’ or ‘ice’. If not given, it defaults to ‘snow’. ‘data’ must contain enough information to build either a snowpack or an ice_column. The minimum requirements are:

  • for a snowpack: (‘z’ or ‘thickness’), ‘density’, ‘microstructure_model’ and the arguments required by the microstructural_model.

  • for an ice column: ice_type, (‘z’ or ‘thickness’), ‘temperature’, ‘salinity’, ‘microstructure_model’ and the arguments required by the microstructural_model.

When reading a dataframe from disk for instance, it is convenient to use df.rename(columns={…}) to map the column names of the file to the column names required by SMRT.

If ‘z’ is given, the thickness is deduced using compute_thickness_from_z.

Warning

Using this function is a bit dangerous as any unrecognized column names are silently ignored. For instance, a column named ‘Temperature’ is ignored (due to the uppercase), and the temperature in the snowpack will be set to the default value (273.15 K). This issue applies to any optional argument.

Note

make_medium creates layers using all the columns in the dataframe. It means that any column name becomes an attribute of the layer objects, even if not recognized/used by SMRT. This can be seen as an interesting feature to store information in layers, but this is also dangerous if column names collide with internal layer attributes or method names. For this reason, this function is unsecure if the snowpack data are pulled from the internet or external source. Always check the content of the file, and it is recommended to drop all the unnecessary columns with df.drop(columns=[…]) before calling make_medium.

Parameters:

  • data – DataFrame or dict containing layer information.

  • surface – Optional; surface interface.

  • interface – Optional; internal interface.

  • substrate – Optional; substrate.

  • **kwargs – Additional columns to add to the DataFrame.

Returns:

The constructed multi-layered medium.

Return type:

Snowpack

make_snowpack(thickness, microstructure_model, density, interface=None, surface=None, substrate=None, atmosphere=None, **kwargs)

Build a multi-layered snowpack. Each parameter can be an array, list or a constant value.

Parameters:

  • thickness – Thicknesses of the layers in meter (from top to bottom). The last layer thickness can be “numpy.inf” for a semi-infinite layer. Any layer with zero thickness is removed.

  • microstructure_model – Microstructure model to use (e.g. sticky_hard_spheres or independent_sphere or exponential).

  • surface – Type of surface interface, flat/fresnel is the default. If surface and interface are both set, the interface must be a constant referring to all the “internal” interfaces.

  • interface – Type of interface, flat/fresnel is the default. It is usually a string for the interfaces without parameters (e.g. Flat or Transparent) or is created with make_interface in more complex cases. Interface can be a constant or a list. In the latter case, its length must be the same as the number of layers, and interface[0] refers to the surface interface.

  • density – Densities of the layers.

  • substrate – Set the substrate of the snowpack. Another way to add a substrate is to use the + operator (e.g. snowpack + substrate).

  • **kwargs – All the other parameters (temperature, microstructure parameters, emmodel, etc.) are given as optional arguments (e.g. temperature=[270, 250]). They are passed for each layer to the function make_snow_layer(). Thus, the documentation of this function is the reference. It describes precisely the available parameters. The microstructure parameter(s) depend on the microstructure_model used and is documented in each microstructure_model module.

Example:

sp = make_snowpack([1, 10], "exponential", density=[200,300], temperature=[240, 250], corr_length=[0.2e-3, 0.3e-3])
make_snow_layer(layer_thickness, microstructure_model, density, temperature=273.15, ice_permittivity_model=None, background_permittivity_model=1.0, volumetric_liquid_water=None, liquid_water=None, salinity=0, medium='snow', **kwargs)

Make a snow layer for a given microstructure_model.

The microstructural parameters depend on the microstructural model and should be given as additional arguments to this function. To know which parameters are required or optional, refer to the documentation of the specific microstructure model used.

Parameters:

  • layer_thickness – Thickness of snow layer in m.

  • microstructure_model – Module name of microstructure model to be used.

  • density – Density of snow layer in kg m -3. Includes the ice and water phases.

  • temperature – Temperature of layer in K.

  • ice_permittivity_model – Permittivity formulation of the scatterers (default is ice_permittivity_matzler87).

  • background_permittivity_model – Permittivity formulation for the background (default is air).

  • volumetric_liquid_water – Volume of liquid water with respect to the volume of snow (default=0).

  • liquid_water – May be deprecated in the future (use instead volumetric_liquid_water): volume of liquid water with respect to ice+water volume (default=0). liquid_water = water_volume / (ice_volume + water_volume).

  • salinity – Salinity in kg kg -1, for using PSU as unit see PSU constant in smrt module (default = 0).

  • medium – Indicates which medium the layer is made of (“snow” is a default). It is used when emmodel is a dictionary mapping from medium to emmodels in make_model().

  • **kwargs – Other microstructure parameters are given as optional arguments but may be required.

Returns:

Instance of SnowLayer.

Return type:

SnowLayer

class SnowLayer(*args, density=None, volumetric_liquid_water=None, liquid_water=None, **kwargs)

Bases: Layer

Specialized Layer class for snow. This should not be used directly by users, instead use make_snow_layer()

This class is necessary to deal with the calculation of the frac_volume and the liquid_water from density and volumetric_liquid_water. Alternatively it is possible to set liquid_water directly but this is not recommended anymore.

update(density=None, volumetric_liquid_water=None, liquid_water=None, **kwargs)

Update the density and/or volumetric_liquid_water.

This method must be used every time density and/or volumetric_liquid_water are changed. Setting directly the corresponding attributes of the Layer object raises an error because a recalculation of the frac_volume and liquid_volume is necessary every time one of these variables is changed.

Parameters:

  • density – New density value.

  • volumetric_liquid_water – New volumetric_liquid_water value.

  • liquid_water – New liquid_water value.

  • **kwargs – Other attributes to update.

static compute_frac_volumes(density, volumetric_liquid_water=None, liquid_water=None)

Compute and return the fractional volumes for ice and liquid water.

The calculations are:

  • frac_volume = (ice+water) / (ice+water+air)

  • liquid_water = (water) / (ice+water)

Parameters:

  • density – Density of the layer.

  • volumetric_liquid_water – Volumetric liquid water.

  • liquid_water – Liquid water.

Returns:

tuple with (frac_volume, liquid_water)

make_ice_column(ice_type, thickness, temperature, microstructure_model, brine_inclusion_shape='spheres', salinity=0.0, brine_volume_fraction=None, brine_volume_model=None, brine_permittivity_model=None, ice_permittivity_model=None, saline_ice_permittivity_model=None, porosity=0, density=None, add_water_substrate=True, surface=None, interface=None, substrate=None, atmosphere=None, **kwargs)

Build a multi-layered ice column. Each parameter can be an array, list or a constant value.

ice_type argument determines the type of ice, which has a big impact on how the medium is modelled and the parameters:

  • First year ice is modelled as scattering brines embedded in a pure ice background

  • Multi year ice is modelled as scattering air bubbles in a saline ice background (but brines are non-scattering in this case).

  • Fresh ice is modelled as scattering air bubbles in a pure ice background (but brines are non-scattering in this case).

First-year and multi-year ice are equivalent only if scattering and porosity are null. It is important to understand that in multi-year ice scattering by brine pockets is neglected because scattering is only due to air bubbles. This limitation comes from the unability of emmodels implemented up to now to deal with three-phase media.

Parameters:

  • ice_type – Ice type. Options are “firstyear”, “multiyear”, “fresh”.

  • thickness – thicknesses of the layers in meter (from top to bottom). The last layer thickness can be “numpy.inf” for a semi-infinite layer. Any layer with zero thickness is removed.

  • temperature – temperature of ice/water in K.

  • brine_inclusion_shape – assumption for shape of brine inclusions. So far, “spheres” or “random_needles” (i.e. elongated ellipsoidal inclusions), and “mix” (a mix of the two) are implemented.

  • salinity – salinity of ice/water in kg kg -1 (see PSU constant in smrt module). Default is 0. If neither salinity nor brine_volume_fraction are given, the ice column is considered to consist of fresh water ice.

  • brine_volume_fraction – brine / liquid water fraction in sea ice. Can be a value or a function depending on temperature and salinity. See the module smrt.permittivity.brine for available options. This parameter is optional, if not given brine volume fraction is calculated from temperature and salinity in brine_volume_cox83_lepparanta88().

  • density – density of ice layer in kg m -3.

  • porosity – porosity of ice layer (0 - 1). Default is 0.

  • add_water_substrate – Adds a substrate made of water below the ice column. Possible arguments are True (default) or False. If True looks for ice_type to determine if a saline or fresh water layer is added and/or uses the optional arguments ‘water_temperature’, ‘water_salinity’ of the water substrate.

  • surface – type of surface interface, flat/fresnel is the default. If surface and interface are both set, the interface must be a constant refering to all the “internal” interfaces.

  • interface – type of interface, flat/fresnel is the default. It is usually a string for the interfaces without parameters (e.g. Flat or Transparent) or is created with make_interface() in more complex cases. Interface can be a constant or a list. In the latter case, its length must be the same as the number of layers, and interface[0] refers to the surface interface.

  • substrate – if add_water_substrate is False, the substrate can be prescribed with this argument.

All the other optional arguments are passed for each layer to the function make_ice_layer(). The documentation of this function describes in detail the parameters used/required depending on ice_type.

make_ice_layer(ice_type, layer_thickness, temperature, salinity, microstructure_model, brine_inclusion_shape='spheres', brine_volume_fraction=None, brine_permittivity_model=None, porosity=0, density=None, ice_permittivity_model=None, saline_ice_permittivity_model=None, medium='ice', **kwargs)

Make an ice layer for a given microstructure_model (see also make_ice_column() to create many layers). The microstructural parameters depend on the microstructural model and should be given as additional arguments to this function. To identify which parameters are available, required or optional, refer to the documentation of the specific microstructure model used.

Parameters:

  • ice_type – Assumed ice type.

  • layer_thickness – Thickness of ice layer in m.

  • temperature – Temperature of layer in K.

  • salinity – (firstyear and multiyear) Salinity in kg kg -1 (see PSU constant in smrt module).

  • brine_inclusion_shape – (firstyear and multiyear) Assumption for shape of brine inclusions (so far, “spheres” and “random_needles” (i.e. elongated ellipsoidal inclusions), and “mix_spheres_needles” are implemented)

  • brine_volume_fraction – Brine / liquid water fraction in sea ice. Can be a value or a function depending on temperature and salinity. See the module smrt.permittivity.brine for available options. This parameter is optional, if not given brine volume fraction is calculated from temperature and salinity in brine_volume_cox83_lepparanta88.

  • brine_permittivity_model – (firstyear and multiyear) Brine permittivity formulation (default is brine_permittivity_stogryn85).

  • density – (multiyear) Density of ice layer in kg m -3. If not given, density is calculated from temperature, salinity and ice porosity.

  • porosity – (mutliyear and fresh) Air porosity of ice layer (0..1). Default is 0.

  • ice_permittivity_model – (all) Pure ice permittivity formulation (default is ice_permittivity_matzler06 for firstyear and fresh, and saline_ice_permittivity_pvs_mixing for multiyear).

  • saline_ice_permittivity_model – (multiyear) Model to mix ice and brine. The default uses polder van staten and ice_permittivity_model and brine_permittivity_model. It is highly recommended to use the default.

  • **kwargs – Other microstructure parameters are given as optional arguments but may be required.

  • medium – Indicates which medium the layer is made of (“ice” is a default). It is used when emmodel is a dictionary mapping from medium to emmodels in make_model.

Returns:

Instance of Layer.

Return type:

Layer

make_water_body(layer_thickness=1000, temperature=273.15, salinity=0, water_permittivity_model=None, foam_frac_volume=0, surface=None, atmosphere=None, substrate=None)

Make a water body with a single layer of water at given temperature and salinity.

Note

Water is a very strong absorber even fresh water, it is unlikely that the layers under a water body could be seen by microwaves. If really needed anyway, a multi-layer water body or a water layer on another medium (e.g. ice) can be built using the addition operator.

Water has a strong real permittivity and when used in combination with the DORT solver, it is recommended to increase the n_max_stream option of the solver to get enough streams in the air (read about streams in Picard et al. 2018).

Parameters:

  • layer_thickness – Thickness of ice layer in m. If the thickness is zero, a transparent layer is added.

  • temperature – Temperature of layer in K.

  • salinity – Salinity in kg kg -1 (see PSU constant in smrt module).

  • water_permittivity_model – Water permittivity formulation (default is seawater_permittivity_klein76).

  • foam_frac_volume – Fractional volume of air bubbles in the water. See for instance Hwang et al. 2019. https://doi.org/10.1175/JPO-D-19-0061.1 . Note that the permittivity mixing formula suggested in that paper is different from the Polder van Santen used in most emmodels in SMRT.

  • foam_bubble_radius – Effective radius of the foam bubbles. See for instance Golbraikh and Shtemler, 2018 https://doi.org/10.1007/s10236-018-1166-4

  • surface – Type of surface interface. Flat surface (Fresnel coefficient) is the default.

  • substrate – The substrate under the water layer.

Returns:

The constructed water body.

Return type:

Snowpack

make_water_layer(layer_thickness, temperature=273.15, salinity=0, water_permittivity_model=None, foam_frac_volume=0, foam_bubble_radius=0.0001, **kwargs)

Make a water layer at given temperature and salinity.

Parameters:

  • layer_thickness – Thickness of ice layer in m.

  • temperature – Temperature of layer in K.

  • salinity – Salinity in kg kg -1 (see PSU constant in smrt module).

  • water_permittivity_model – Water permittivity formulation (default is seawater_permittivity_klein76())

  • foam_frac_volume – Fractional volume of air bubbles in the water. See for instance Hwang et al. 2019. https://doi.org/10.1175/JPO-D-19-0061.1 . Note that the permittivity mixing formula suggested in that paper is different from the Polder van Santen used in most emmodels in SMRT.

  • foam_bubble_radius – Effective radius of the foam bubbles. See for instance Golbraikh and Shtemler, 2018 https://doi.org/10.1007/s10236-018-1166-4

Returns:

Instance of Layer.

Return type:

Layer

water_parameters(ice_type, **kwargs)

Return the water parameters to make a semi-infinite water layer.

Parameters:

  • ice_type – Type of ice used to determine if a saline or fresh water layer is added.

  • water_temperature – Water temperature.

  • water_salinity – Water salinity.

  • water_depth – Depth of the water layer.

Returns:

WaterParameter with water_temperature, water_salinity, water_permittivity_model.

Return type:

namedtuple

bulk_ice_density(temperature, salinity, porosity)

Compute bulk density of sea ice (in kg m -3), when considering the influence from brine, solid salts, and air bubbles in the ice.

Formulation from Cox & Weeks (1983): Equations for determining the gas and brine volumes in sea ice samples, J Glac. Developed for temperatures between -2–30°C. For higher temperatures (>2°C) is used the formulation from Lepparanta & Manninen (1988): The brine and gas content of sea ice with attention to low salinities and high temperatures.

Parameters:

  • temperature – Temperature in K

  • salinity – Salinity in kg kg -1 (see PSU constant in smrt module).

  • porosity – Fractional volume of air inclusions (0..1)

Returns:

Density of ice mixture in kg m -3

Return type:

float

make_generic_stack(thickness, temperature=273.15, ks=0, ka=0, effective_permittivity=1, interface=None, substrate=None, atmosphere=None)

Build a multi-layered medium with prescribed scattering and absorption coefficients and effective permittivity. Must be used with smrt.emmodel.prescribed_kskaeps emmodel.

Parameters:

  • thickness – Thicknesses of the layers in meter (from top to bottom). The last layer thickness can be “numpy.inf” for a semi-infinite layer. Any layer with zero thickness is removed.

  • temperature – Temperature of layers in K

  • ks – Scattering coefficient of layers in m :sum:`-1`.

  • ka – Absorption coefficient of layers in m :sum:`-1`.

  • interface – Type of interface, flat/fresnel is the default

Returns:

The constructed multi-layered medium.

Return type:

Snowpack

Example:

sp = make_snowpack([1, 10], "exponential", density=[200,300], temperature=[240, 250], corr_length=[0.2e-3, 0.3e-3])
make_generic_layer(layer_thickness, ks=0, ka=0, effective_permittivity=1, temperature=273.15)

Make a generic layer with prescribed scattering and absorption coefficients and effective permittivity. Must be used with smrt.emmodel.prescribed_kskaeps emmodel.

Parameters:

  • layer_thickness – Thickness of ice layer in m.

  • temperature – Temperature of layer in K.

  • ks – Scattering coefficient of layers in m :sum:`-1`.

  • ka – Absorption coefficient of layers in m :sum:`-1`.

Returns:

Instance of Layer.

Return type:

Layer

add_transparent_layer(snowpack)

Adds a transparent layer to the snowpack.

Parameters:

snowpack – The substrate under the transparent layer.

Example:

sp = add_transparent_layer(sp)
make_transparent_volume(substrate=None, atmosphere=None)

Build a transparent single-layer snowpack. This is useful to run SMRT with substrate only, without any volume.

Parameters:

substrate – The substrate under the transparent layer.

Example:

sp = make_transparent_volume()
make_atmosphere(atmosphere_model, **kwargs)

Make an atmospheric single-layer using the prescribed atmosphere model.

Warning

This function is subject to change in the future when refactoring how SMRT deals with atmosphere.

Parameters:

  • atmosphere_model – The name of the model to use. The available models are in smrt.atmosphere.

  • **kwargs – All the parameters used by the atmosphere_model.

Returns:

Instance of the atmosphere model.

compute_thickness_from_z(z)

Computes the thickness of layers given the elevation z. Whatever the sign of z, the order MUST be from the topmost layer to the lowermost.

Several situations are accepted and interpreted as follows:

  • z is positive and decreasing. The first value is the height of the surface above the ground (z=0) and z represents the top elevation of each layer. This is typical of the seasonal snowpack.

  • z is negative and decreasing. The first value is the elevation of the bottom of the first layer with respect to the surface (z=0). This is typical of a snowpack on ice-sheet.

  • z is positive and increasing. The first value is the depth of the bottom of the first layer with respect to the surface. This is typical of a snowpack on ice-sheet.

  • Other case, when z is not monotonic or is increasing with negative value raises an error.

Because z indicates the top or the bottom of a layer depending whether z=0 is the ground or the surface, the value 0 can never be in z. This raises an error.

Parameters:

z – Elevation array.

Returns:

Thickness array.

Return type:

ndarray

smrt.inputs.make_soil module

This module provides a function to build soil model and some soil permittivity formulae.

To create a substrate, use or implement a helper function such as make_soil. This function is able to automatically load a specific soil model and provides some soil permittivity formulae as well.

Example:

from smrt import make_soil
soil = make_soil("soil_wegmuller", "dobson85", moisture=0.2, sand=0.4, clay=0.3, drymatter=1100, roughness_rms=1e-2)

It is recommended to first read the documentation of make_soil and then explore the different types of soil models.

make_soil(substrate_model, permittivity_model, temperature, moisture=None, sand=None, clay=None, drymatter=None, **kwargs)

Constructs a soil instance based on a given surface electromagnetic model, a permittivity model and parameters.

Parameters:

  • substrate_model – Name of substrate model, can be a class or a string. e.g. fresnel, wegmuller…

  • permittivity_model – Permittivity model to use. Can be a name (“hut_epss”, “dobson85”, “montpetit2008”), a function of frequency and temperature or a complex value.

  • temperature – Temperature of the soil.

  • moisture – Soil moisture in m^3 m^-3 to compute the permittivity. This parameter is used depending on the permittivity_model.

  • sand – Soil relative sand content. This parameter is used or not depending on the permittivity_model.

  • clay – Soil relative clay content. This parameter is used or not depending on the permittivity_model.

  • drymatter – Soil content in dry matter in kg m^-3. This parameter is used or not depending on the permittivity_model.

  • **kwargs – Geometrical parameters depending on the substrate_model. Refer to the document of each model to see the list of required and optional parameters. Usually, it is roughness_rms, corr_length, …

Returns:

Instance of the soil substrate model.

Example (TOTEST):

bottom = substrate.make('Flat', permittivity_model=complex('6-0.5j'))
bottom = substrate.make('Wegmuller', permittivity_model='soil', roughness_rms=0.25, moisture=0.25)
soil_dielectric_constant_monpetit2008(frequency, temperature)

Computes the soil dielectric constant using the Montpetit et al. (2018) formulation.

The formulation is only valid for below-freezing point temperature.

Reference:

Montpetit, B., Royer, A., Roy, A., & Langlois, A. (2018). In-situ passive microwave emission model parameterization of sub-arctic frozen organic soils. Remote Sensing of Environment, 205, 112–118. https://doi.org/10.1016/j.rse.2017.10.033

Parameters:

  • frequency – Frequency in Hz.

  • temperature – Temperature in Kelvin.

Returns:

Soil dielectric constant.

Return type:

complex

smrt.inputs.sensor_list module

The sensor configuration includes all the information describing the sensor viewing geometry (incidence, …) and operating parameters (frequency, polarization, …). The easiest and recommended way to create a Sensor instance is to use one of the convenience functions listed below. The generic functions passive and active should cover all the usages, but functions for specific sensors are more convenient. See examples in the functions documentation below. We recommend to add new sensors/functions here and share your file to be included in SMRT.

passive(frequency, theta, polarization=None, channel_map=None, name=None)

Return a generic configuration for passive microwave sensor.

Return a Sensor for a microwave radiometer with given frequency, incidence angle and polarization

Parameters:

  • frequency – frequency in Hz

  • theta – viewing angle or list of viewing angles in degrees from vertical. Note that some RT solvers compute all viewing angles whatever this configuration because it is internally needed part of the multiple scattering calculation. It it therefore often more efficient to call the model once with many viewing angles instead of calling it many times with a single angle.

  • polarization – H and/or V polarizations. Both polarizations is the default. Note that most RT solvers compute all the polarizations whatever this configuration because the polarizations are coupled in the RT equation.

  • channel_map – map channel names (keys) to configuration (values). A configuration is a dict with frequency, polarization and other such parameters to be used by Result to select the results. (Default value = None)

  • name – name of the sensor (Default value = None)

Returns:

py:class:Sensor instance

Usage example:

from smrt import sensor_list radiometer = sensor_list.passive(18e9, 50) radiometer = sensor_list.passive(18e9, 50, “V”) radiometer = sensor_list.passive([18e9,36.5e9], [50,55], [“V”,”H”])

active(frequency, theta_inc, theta=None, phi=None, polarization_inc=None, polarization=None, channel_map=None, name=None)

Return a generic configuration for active microwave sensor.

Return a Sensor for a radar with given frequency, incidence and viewing angles and polarization

If polarizations are not specified, quad-pol is the default (VV, VH, HV and HH). If the angle of incident radiation is not specified, backscatter will be simulated

Parameters:

  • frequency – frequency in Hz.

  • theta_inc – incident angle in degrees from the vertical.

  • theta – viewing zenith angle in degrees from the vertical. By default, it is equal to theta_inc which corresponds to the backscatter direction.

  • phi – viewing azimuth angle in degrees from the incident direction. By default, it is pi which corresponds to the backscatter direction.

  • polarization_inc – list of polarizations of the incidence wave (‘H’ or ‘V’ or both).

  • polarization – list of viewing polarizations (‘H’ or ‘V’ or both).

  • channel_map (dict, optional) – map channel names (keys) to configuration (values). A configuration is a dict with frequency, polarization and other such parameters to be used by Result to select the results.

  • name (string, optional) – name of the sensor

Returns:

py:class:Sensor instance

Usage example:

from smrt import sensor_list scatterometer = sensor_list.active(frequency=18e9, theta_inc=50) scatterometer = sensor_list.active(18e9, 50, 50, 0, “V”, “V”) scatterometer = sensor_list.active([18e9,36.5e9], theta=50, theta_inc=50, polarization_inc=[“V”, “H”], polarization=[“V”, “H”])

amsre(channel=None, frequency=None, polarization=None, theta=55)

Returns a configuration for AMSR-E sensor.

This function can be used to simulate all 12 AMSR-E channels i.e. frequencies of 6.925, 10.65, 18.7, 23.8, 36.5 and 89 GHz at both polarizations H and V. Alternatively single channels can be specified with 3-character identifiers. 18 and 19 GHz can be used interchangeably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if both H and V polarization are needed (at 37 GHz for instance), use channel=”37” instead of channel=[“37V”, “37H”] as this will result in a more efficient simulation, because most rtsolvers anyway compute both polarizations in one shot.

Parameters:

  • channel – Single channel identifier (3-character string).

  • frequency – Frequency value.

  • polarization – Polarization.

  • theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

Example:

from smrt import sensor
radiometer = sensor.amsre()  # Simulates all channels
radiometer = sensor.amsre('36V')  # Simulates 36.5 GHz channel only
radiometer = sensor.amsre('06H')  # 6.925 GHz channel
amsr2(channel=None, frequency=None, polarization=None, theta=55)

Returns a configuration for AMSR-2 sensor.

This function can be used to simulate all 14 AMSR2 channels i.e. frequencies of 6.925, 10.65, 18.7, 23.8, 36.5 and 89 GHz at both polarizations H and V. Alternatively single channels can be specified with 3-character identifiers. 18 and 19 GHz can be used interchangeably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if both H and V polarization are needed (at 37 GHz for instance), use channel=”37” instead of channel=[“37V”, “37H”] as this will result in a more efficient simulation, because most rtsolvers anyway compute both polarizations in one shot.

Parameters:

  • channel – Single channel identifier (3-character string).

  • frequency – Frequency value.

  • polarization – Polarization.

  • theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

Example:

from smrt import sensor
radiometer = sensor.amsre()  # Simulates all channels
radiometer = sensor.amsre('36V')  # Simulates 36.5 GHz channel only
radiometer = sensor.amsre('06H')  # 6.925 GHz channel
cimr(channel=None, frequency=None, polarization=None, theta=55)

Returns a configuration for CIMR sensor.

This function can be used to simulate all 10 CIMR channels i.e. frequencies of 1.4, 6.9, 10.6, 18.7, 36.5 GHz at both polarizations H and V. Alternatively single channels can be specified with 3-character identifiers. 18 and 19 GHz can be used interchangeably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if both H and V polarization are needed (at 37 GHz for instance), use channel=”37” instead of channel=[“37V”, “37H”] as this will result in a more efficient simulation, because most rtsolvers anyway compute both polarizations in one shot.

Parameters:

  • channel – Single channel identifier (3-character string).

  • frequency – Frequency value.

  • polarization – Polarization.

  • theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

quikscat(channel=None, theta=None)

Returns a configuration for quikscat sensor.

This function can be used to simulate the 4 QUIKSCAT channels i.e. incidence angles 46° and 54° and HH and VV polarizations. Alternatively a subset of these channels can be specified with 4-character identifiers with polarization first .e.g. HH46, VV54

Parameters:

  • channel – Single channel identifier (4-character string).

  • theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

ascat(theta=None)

Returns a configuration for ASCAT on MetOp satellites.

Characteristics of the observation configuration: https://ieeexplore.ieee.org/document/7815274

This function returns a sensor at 5.255 GHz (C-band) and VV polarization. The incidence angle can be chosen or is by default from 25° to 65° every 5°

Parameters:

theta – Incidence angle (between 25 and 65° in principle).

Returns:

Instance of Sensor.

Return type:

Sensor

sentinel1(theta=None)

Returns a configuration for C-SAR on Sentinel 1.

This function returns a sensor at 5.405 GHz (C-band). The incidence angle can be chosen or is by default from 20 to 45° by step of 5°

Parameters:

theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

smos(theta=None)

Returns a configuration for MIRAS on SMOS.

This function returns a passive sensor at 1.41 GHz (L-band). The incidence angle can be chosen or is by default from 0 to 60° by step of 5°

Parameters:

theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

smap(mode, theta=40)

Returns a configuration for the passive (mode=’P’) and active (mode=’A’) sensor on SMAP.

This function returns either a passive sensor at 1.4 GHz (L-band) sensor or an active sensor at 1.26 GHz. The incidence angle is 40°.

Parameters:

  • mode – ‘P’ for passive, ‘A’ for active.

  • theta – Incidence angle.

Returns:

Instance of Sensor.

Return type:

Sensor

Raises:

SMRTError – If mode is not ‘A’ or ‘P’.

cristal_amrcr(channel)

3-frequencies:18.7, 23.8 and 34 GHz. An experimental high-frequency component, HRMR is alongside for higher resolution, see HRMR page for details. Evolution of the AMR flown on JASON 2 and 3

smrt.inputs.lrm_altimeter_list module

envisat_ra2(channel=None, pitch_angle_deg=0, roll_angle_deg=0)

Returns an Altimeter instance for the ENVISAT RA2 altimeter.

Parameters:

channel – can be ‘S’, ‘Ku’, or both. Default is both.

sentinel3_sral(channel=None, pitch_angle_deg=0, roll_angle_deg=0)

return an Altimeter instance for the Sentinel 3 SRAL instrument.

Parameters:

channel – can be ‘Ku’ only (‘C’ is to be implemented)

saral_altika(pitch_angle_deg=0, roll_angle_deg=0)

return an Altimeter instance for the Saral/AltiKa instrument.

cryosat2_lrm(pitch_angle_deg=0, roll_angle_deg=0)

Return an altimeter instance for CryoSat-2

Parameters from https://earth.esa.int/web/eoportal/satellite-missions/c-missions/cryosat-2 Altitude from https://doi.org/10.1016/j.asr.2018.04.014 Beam width is 1.08 along track and 1.2 across track

asiras_lam(altitude=None, pitch_angle_deg=0, roll_angle_deg=0)

Return an altimeter instance for ASIRAS in Low Altitude Mode

Parameters from https://earth.esa.int/web/eoportal/airborne-sensors/asiras Beam width is 2.2 x 9.8 deg

Brown1997 can not take elliptical footprints into account whereas Newkirk1992 model can. Select it in the waveform model.

smrt.inputs.sar_altimeter_list module

cryosat2_sarm(pitch_angle_deg=0, roll_angle_deg=0, force_circular_antenna=False)

Return an altimeter instance for CryoSat-2: SAR mode without oversampling but with hamming window

Parameters from https://docslib.org/doc/3527464/cryosat-product-handbook https://earth.esa.int/eogateway/documents/20142/37627/CryoSat-Baseline-D-Product-Handbook.pdf (page 13)

sentinel3_sarm(band: str, surface: str, pitch_angle_deg=0, roll_angle_deg=0)

Return an altimeter instance for Sentienl 3

Documented in: https://sentinel.esa.int/documents/247904/4871083/Sentinel-3+SRAL+Land+User+Handbook+V1.1.pdf

cristal(band: str, pitch_angle_deg=0, roll_angle_deg=0, force_circular_antenna=False)

Return an altimeter instance for CryoSat-2: SAR mode without oversampling but with hamming window

Parameters from https://docslib.org/doc/3527464/cryosat-product-handbook https://earth.esa.int/eogateway/documents/20142/37627/CryoSat-Baseline-D-Product-Handbook.pdf (page 13)