exosim.recipes.radiometric_model#

Classes#

RadiometricModel

Pipeline to create the radiometric model.

Module Contents#

class RadiometricModel(options_file, output_file, store_config=False, plot=False, isolate_every_opt=False, slim_output=False)[source]#

Bases: exosim.recipes.create_focal_plane.CreateFocalPlane

Pipeline to create the radiometric model. This pipeline has three working modes:

it can load an already produced focal plane and use it to estimate a radiometric model;
it can produce a single source focal plane and estimate the radiometric model;
it can load a target list and produce the radiometric model for each target of the target list.

Variables:

mainConfig (dict) – This is parsed from LoadOptions
output (Output) – input/output file
payloadConfig (dict) – payload configuration dictionary extracted from mainConfig`
table (QTable) – table for the radiometric estimations

Parameters:

options_file (str | dict)
output_file (str)
store_config (bool)
plot (bool)
isolate_every_opt (bool)
slim_output (bool)

Examples

If the user wants to estimate the radiometric model of an existing focal plane

>>> import exosim.recipes as recipes
>>> rm = recipes.RadiometricModel(options_file= 'main _configuration.xml',
>>>                                output_file = 'focal_plane.h5')

Otherwise, if a focal plane has not been produced yet, this recipe can produce it, if a destination not existing file is provided:

>>> import exosim.recipes as recipes
>>> rm = recipes.RadiometricModel(options_file= 'main _configuration.xml',
>>>                                output_file = 'desired_output.h5')

In both cases, to store the produced table into the output file, the write is to be used:

>>> rm.write()

master_table = None[source]#

table = None[source]#

output_file[source]#

out_folder[source]#

plot_folder[source]#

plot = False[source]#

plot_apertures()[source]#

Return type:: None

target_list_pipeline(store_config, slim_output=False)[source]#

Executes the radiometric model pipeline for a list of targets.

Parameters:

store_config (bool) – If True, the configuration for each target will be stored in its respective output group.
slim_output (bool) – If True, only the necessary data will be stored in the output file to reduce its size

Return type:

None

write_table(source_name=None)[source]#

Return type:: None

populate_source_focal_plane(sources, channel, out=None)[source]#

Populates the focal plane for a given channel with the provided sources.

Parameters:

sources (dict) – A dictionary of sources to propagate.
channel (Channel) – The channel object to populate the focal plane for.
out (OutputType, optional) – The output object. Defaults to None.

Return type:

None

single_file_pipeline()[source]#

Radiometric pipeline to run for a single target with an already produced focal plane. The involved steps are:

creation of the wavelength table with create_table;
estimation of the apertures sizes and number of pixels involved with compute_apertures;
estimation of the signals in the apertures for the sub foregrounds, if any: compute_sub_foregrounds_signals;
estimation of the total foreground signal in the apertures: compute_foreground_signals;
estimation of the source focal plane signal in the aperture: compute_source_signals;
estimation of the saturation time in the channel: compute_saturation;

The pipeline will update the table attribute.

Return type:: None

common_noise_pipeline()[source]#

Radiometric pipeline to run starting from a radiometric table with already estimated signals. It computes the noise.

estimation of the multiaccum factors compute_multiaccum;
estimation shot noise compute_photon_noise;
update total noise update_total_noise

The pipeline will update the table attribute.

Return type:: None

compute_apertures(target_name=None, store=True)[source]#

Estimates the photometric aperture for each spectral bin using EstimateApertures by default.

Parameters:

target_name (str, optional) – Name of the target to compute apertures for. Defaults to None.
store (bool)

Returns:

Table with the apertures for each channel and bin.

Return type:

QTable

write(output_file=None, target=None)[source]#

It adds the radiometric table to the output. If the table exists already in the output file, it replaces it.

Parameters:

output_file (str, optional) – Path to the output file. Default is self.output.
target (str, optional) – Target name in the output file where to store the table. Defaults to None.

Return type:

None

compute_sub_foregrounds_signals(out=None, channels_path=None)[source]#

Estimates the radiometric signals on the foreground sub focal planes for all the channels and returns a table with all the contributions.

It uses ComputeSubFrgSignalsChannel by default.

Parameters:

out (OutputType, optional) – The output object. Defaults to None.
channels_path (str, optional) – Path to the channels in the output file. Defaults to None.

Returns:

Signal table.

Return type:

QTable

rebin_efficiencies(channels_path=None)[source]#

Rebins the efficiencies in the radiometric table to match the wavelength bins. It uses RebinEfficiencies by default.

Return type:: None

compute_foreground_signals(channels_path=None)[source]#

Estimates the radiometric signals on the foreground focal plane for all the channels and returns a table with all the contributions.

It uses ComputeSignalsChannel by default.

Parameters:: channels_path (str, optional) – Path to the channels in the output file. Defaults to None.
Returns:: Signal table.
Return type:: QTable

compute_total_signals(table, parameters, focal_plane, computeSignalsChannel)[source]#

Return type:: numpy.ndarray

compute_source_signals(channels_path=None)[source]#

Estimates the radiometric signals on the source focal plane for all the channels and returns a table with all the contributions.

It uses ComputeSignalsChannel by default.

Parameters:: channels_path (str, optional) – Path to the channels in the output file. Defaults to None.
Returns:: Signal table.
Return type:: QTable

remove_oversampling(configurations)[source]#

Remove oversampling from the configurations. This is useful to avoid oversampling in the focal plane.

Parameters:: configurations (dict) – configurations dictionary
Returns:: configurations dictionary without oversampling
Return type:: dict