smrt.inputs package¶

Submodules¶

smrt.inputs.altimeter_list module¶

envisat_ra2(channel=None)¶

return an Altimeter instance for the ENVISAT RA2 altimeter.

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

sentinel3_sral(channel=None)¶

return an Altimeter instance for the Sentinel 3 SRAL instrument.

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

saral_altika()¶: return an Altimeter instance for the Saral/AltiKa instrument.

cryosat2_lrm()¶

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

cryosat2_sin()¶

Return an altimeter instance for CryoSat-2: SIN mode

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

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

smrt.inputs.make_medium module¶

The helper functions in this module are used to create snowpacks, sea-ice and other media. They 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. For example:

from smrt import make_snowpack

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

creates 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 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 optinal 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 a 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 ignore (due to the uppercase), and the temperature in the snowpack will be set to its default value (273.15 K). This issue applies to any optional argument. Double ckeck the spelling of the columns.

** Note **: make_medium create laters 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. 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.

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:

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

thickness – thicknesses of the layers in meter (from top to bottom). The last layer thickness can be “numpy.inf” for a semi-infinite layer.
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 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.
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.

e.g.:

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 (see also make_snowpack() to create many layers). 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:

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 depreciated 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, for using PSU as unit see PSU constant in smrt module (default = 0). medium – indicate 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 (in Python words) but may be required (in SMRT words). See the documentation of the microstructure model.
Returns:	`SnowLayer` instance

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 depreciated 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, for using PSU as unit see PSU constant in smrt module (default = 0).
medium – indicate 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 (in Python words) but may be required (in SMRT words). See the documentation of the microstructure model.

Returns:

SnowLayer instance

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

Bases: smrt.core.layer.Layer

Specialized Layer class for snow. It deals 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.

Meta private:

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.

static compute_frac_volumes(density, volumetric_liquid_water=None, liquid_water=None)¶: compute and return the fractional volumes: - frac_volume =(ice+water) / (ice+water+air) - liquid_water =(water) / (ice+water)

make_ice_column(ice_type, thickness, temperature, microstructure_model, brine_inclusion_shape='spheres', salinity=0.0, brine_volume_fraction=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 variable 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 is equivalent only if scattering and porosity are nulls. It is important to understand that in multi-year ice scattering by brine pockets is neglected because scattering is due to air bubbles and the emmodel implemented up to now are not able to deal with three-phase media.

Parameters:

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. 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 (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, optional parameter, if not given brine volume fraction is calculated from temperature and salinity in ~.smrt.permittivity.brine_volume_fraction 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.

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.
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 (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, optional parameter, if not given brine volume fraction is calculated from temperature and salinity in ~.smrt.permittivity.brine_volume_fraction
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, porosity=0, density=None, brine_permittivity_model=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 know which parameters are required or optional, refer to the documentation of the specific microstructure model used.

Parameters:

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 (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 – (firstyear and multiyear) brine / liquid water fraction in sea ice, optional parameter, if not given brine volume fraction is calculated from temperature and salinity in ~.smrt.permittivity.brine_volume_fraction 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) brine_permittivity_model – (firstyear and multiyear) brine permittivity formulation (default is brine_permittivity_stogryn85) 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 recommanded to use the default. kwargs – other microstructure parameters are given as optional arguments (in Python words) but may be required (in SMRT words). medium – indicate 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()`

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 (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 – (firstyear and multiyear) brine / liquid water fraction in sea ice, optional parameter, if not given brine volume fraction is calculated from temperature and salinity in ~.smrt.permittivity.brine_volume_fraction
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)
brine_permittivity_model – (firstyear and multiyear) brine permittivity formulation (default is brine_permittivity_stogryn85)
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 recommanded to use the default.
kwargs – other microstructure parameters are given as optional arguments (in Python words) but may be required (in SMRT words).
medium – indicate 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()

See the documentation of the microstructure model.

Returns:	`Layer` instance

make_water_body(layer_thickness=1000, temperature=273, salinity=0, water_permittivity_model=None, surface=None, atmosphere=None, substrate=None)¶

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

Note that 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 build using the addition operator.

Parameters:

Parameters:	layer_thickness – thickness of ice layer in m temperature – temperature of layer in K salinity – salinity in kg/kg (see PSU constant in smrt module) water_permittivity_model – water permittivity formulation (default is seawater_permittivity_klein76) surface – type of surface interface. Flat surface (Fresnel coefficient) is the default. substrate – the substrate under the water layer.

layer_thickness – thickness of ice layer in m
temperature – temperature of layer in K
salinity – salinity in kg/kg (see PSU constant in smrt module)
water_permittivity_model – water permittivity formulation (default is seawater_permittivity_klein76)
surface – type of surface interface. Flat surface (Fresnel coefficient) is the default.
substrate – the substrate under the water layer.

make_water_layer(layer_thickness, temperature=273, salinity=0, water_permittivity_model=None, **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 (see PSU constant in smrt module) water_permittivity_model – water permittivity formulation (default is seawater_permittivity_klein76)

water_parameters(ice_type, **kwargs)¶

Make a semi-infinite water layer.

Parameters:	ice_type – ice_type is used to determine if a saline or fresh water layer is added

The optional arguments are ‘water_temperature’, ‘water_salinity’ and ‘water_depth’ of the water layer.

bulk_ice_density(temperature, salinity, porosity)¶

Computes 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 (see PSU constant in smrt module) porosity – Fractional volume of air inclusions (0..1)
Returns:	Density of ice mixture in kg m ^-3

make_generic_stack(thickness, temperature=273, 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 presribed_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. temperature – temperature of layers in K ks – scattering coefficient of layers in m^-1 ka – absorption coefficient of layers in m^-1 interface – type of interface, flat/fresnel is the default

make_generic_layer(layer_thickness, ks=0, ka=0, effective_permittivity=1, temperature=273)¶

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

Parameters:	layer_thickness – thickness of ice layer in m temperature – temperature of layer in K ks – scattering coefficient of layers in m^-1 ka – absorption coefficient of layers in m^-1
Returns:	`Layer` instance

make_atmosphere(atmosphere_model, **kwargs)¶

make a 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.

compute_thickness_from_z(z)¶

Compute 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 situation are accepted and interpretated as follows: - z is positive and decreasing. The first value is the height of the surface about 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 monoton or is increasing with negative value raises an error.

Because z indicate 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.

smrt.inputs.make_soil module¶

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

To create a substrate, use/implement an 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.

Examples:

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 recommand 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)¶

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

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. moisture – soil moisture in m:sup:3 m:sup:-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:sup:-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, …

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.
moisture – soil moisture in m:sup:3 m:sup:-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:sup:-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, …

Usage example:

::: TOTEST: bottom = substrate.make(‘Flat’, permittivity_model=complex(‘6-0.5j’)) TOTEST: bottom = substrate.make(‘Wegmuller’, permittivity_model=’soil’, roughness_rms=0.25, moisture=0.25)

soil_dielectric_constant_dobson(frequency, tempK, SM, S, C)¶

soil_dielectric_constant_hut(frequency, tempK, SM, sand, clay, dm_rho)¶

soil_dielectric_constant_monpetit2008(frequency, temperature)¶

Soil dielectric constant formulation based on the formulation Montpetit et al. 2018. The formulation is only valid for below-frrezing 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

smrt.inputs.make_substrate module¶

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

Generic configuration for passive microwave sensor.

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

Parameters:

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 (list of characters) – 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 (dict) – 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) – name of the sensor
Returns:	`Sensor` instance

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 (list of characters) – 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 (dict) – 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) – name of the sensor

Returns:

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

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:

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 1-character strings) – list of polarizations of the incidence wave (‘H’ or ‘V’ or both.) polarization (list of 1-character strings) – list of viewing polarizations (‘H’ or ‘V’ or both) channel_map (dict) – 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) – name of the sensor
Returns:	`Sensor` instance

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 1-character strings) – list of polarizations of the incidence wave (‘H’ or ‘V’ or both.)
polarization (list of 1-character strings) – list of viewing polarizations (‘H’ or ‘V’ or both)
channel_map (dict) – 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) – name of the sensor

Returns:

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

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 interchangably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if you need both H and V polarization (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 (3-character string) – single channel identifier
Returns:	`Sensor` instance

Usage 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)¶

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 interchangably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if you need both H and V polarization (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 (3-character string) – single channel identifier
Returns:	`Sensor` instance

Usage 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)¶

Configuration for AMSR-2 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 interchangably to represent 18.7 GHz, similarly either 36 and 37 can be used to represent the 36.5 GHz channel. Note that if you need both H and V polarization (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 (3-character string) – single channel identifier
Returns:	`Sensor` instance

common_conical_pmw(sensor_name, frequency_dict, channel=None, frequency=None, polarization=None, theta=55, name=None)¶

quikscat(channel=None, theta=None)¶

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 (4-character string) – single channel identifier
Returns:	`Sensor` instance

ascat(theta=None)¶

Configuration for ASCAT on ENVISAT sensor.

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

Parameters:	theta (float or sequence) – incidence angle (between 25 and 65° in principle)
Returns:	`Sensor` instance

sentinel1(theta=None)¶

Configuration for C-SAR on Sentinel 1.

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

Parameters:	theta (float or sequence) – incidence angle
Returns:	`Sensor` instance

smos(theta=None)¶

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 defaut from 0 to 60° by step of 5°

Parameters:	theta (float or sequence) – incidence angle
Returns:	`Sensor` instance

smap(mode, theta=40)¶

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

filter_channel_map(channel_map, channel)¶

extract_configuration(channel_map)¶

smrt.inputs.test_make_medium module¶

test_make_snowpack()¶

test_make_snowpack_surface_interface()¶

test_make_snowpack_interface()¶

test_make_snowpack_surface_and_list_interface()¶

test_make_snowpack_with_scalar_thickness()¶

test_make_snowpack_array_size()¶

test_make_lake_ice()¶

test_make_medium()¶

test_make_snowpack_volumetric_liquid_water()¶

test_update_volumetric_liquid_water()¶

test_snow_set_readonly()¶

smrt.inputs.test_make_substrate module¶

smrt.inputs.test_sensor_list module¶

test_map_channel19_to_dictionary()¶

test_map_channel37_to_dictionary()¶

test_amsre_theta_is_55()¶

test_amsre_channel_recognized()¶

test_map_channel06_to_dictionary()¶

test_map_channel07_to_dictionary()¶

test_amsr2_theta_is_55()¶

test_cimr_channel01_to_dictionary()¶

test_cimr_is_55()¶

Module contents¶

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.