pysiral.l1preproc

Submodules

pysiral.l1preproc.procitems

Attributes

`psrlcfg`
`SHOW_DEBUG_MAP`
`L1P_HEMISPHERE_NAMING_DICT`
`L1PInputCLS`
`L1PPROC_CLS_TYPE`

Classes

`StopWatch`
`ProgressIndicator`
`AttrDict`	Short implementation of attrdict.AttrDict using UserDict. The code is based on the solutions shared here
`DefaultLoggingClass`	Template for default pysiral class with logging/error handling capabilities
`ErrorStatus`
`Hemispheres`	Enum for hemispheres.
`L1bDataNC`	Class to export a L1bdata object into a netcdf file
`L1bMetaData`	Container for L1B Metadata information
`Level1bData`	Unified L1b Data Class
`L1PProcItemDef`	Class for validating and processing Level-1 Pre-Processor item definition
`Level1PInputHandlerBase`	Base class (mostly for type checking).
`Level1POutputHandler`	The output handler for l1p product files
`L1PreProcBase`	Template for default pysiral class with logging/error handling capabilities
`L1PreProcCustomOrbitSegment`	A Pre-Processor for input files with arbitrary segment lenght (e.g. CryoSat-2)
`L1PreProcHalfOrbit`	A Pre-Processor for input files with a full orbit around the earth (e.g. ERS-1/2)
`L1PreProcFullOrbit`	A Pre-Processor for input files with a full orbit around the earth (e.g. ERS-1/2)
`L1PreProcPolarOceanCheck`	A small helper class that can be passed to input adapter to check whether the l1 segment is
`Level1PreProcJobDef`	A class that contains all information necessary for the Level-1 pre-processor.

Functions

`get_yaml_config`(→ Union[Dict, ...)	Parses the contents of a configuration file in .yaml format
`get_first_array_index`(array, value)	Get the index in array of the first occurance of `value`
`get_last_array_index`(array, value)	Get the index in array of the last occurance of `value`
`rle`(inarray)	run length encoding. Partial credit to R rle function.
`get_preproc`(→ L1PPROC_CLS_TYPE)	A function returning the pre-processor class corresponding the type definition.
`l1p_debug_map`(→ None)	Create an interactive map of l1p segment

Package Contents

pysiral.l1preproc.psrlcfg

class pysiral.l1preproc.StopWatch

Bases: object

t0 = None

t1 = None

reset()

start()

stop()

get_seconds()

get_duration(fmt='%H:%M:%S')

pysiral.l1preproc.get_yaml_config(filename: str | pathlib.Path, output: str = 'attrdict') → Dict | pysiral.core.legacy_classes.AttrDict

Parses the contents of a configuration file in .yaml format and returns the content in various formats

Parameters:

filename – The full file path of the config file
output – Dict or AttrDict (depends on output keyword)

Returns:

class pysiral.l1preproc.ProgressIndicator(n_steps)

Bases: object

n_steps

index = None

reset()

get_status_report(i, fmt='{step} of {n_steps} ({percent:.2f}%)')

property step

property percent

pysiral.l1preproc.get_first_array_index(array, value): Get the index in array of the first occurance of value

pysiral.l1preproc.get_last_array_index(array, value): Get the index in array of the last occurance of value

pysiral.l1preproc.rle(inarray)

run length encoding. Partial credit to R rle function. Multi datatype arrays catered for including non Numpy returns: tuple (runlengths, startpositions, values)

from: http://stackoverflow.com/questions/1066758/find-length-of-sequences-: of-identical-values-in-a-numpy-array

class pysiral.l1preproc.AttrDict(dict=None, /, **kwargs)

Bases: collections.UserDict

Short implementation of attrdict.AttrDict using UserDict. The code is based on the solutions shared here https://stackoverflow.com/a/76231823 and has been modified to allow nested AttrDict instances.

__getattr__(key)

__setattr__(key, value)

class pysiral.l1preproc.DefaultLoggingClass(cls_name=None)

Bases: object

Template for default pysiral class with logging/error handling capabilities

error

log

class pysiral.l1preproc.ErrorStatus(caller_id='')

Bases: object

caller_id = ''

status = False

codes = []

messages = []

add_error(code, message): Add an error. Error code and messages are arbitrary

raise_on_error(): print error messages and exit program on existing error(s)

get_all_messages()

reset(): Remove all error messages and set to clean status

property message

class pysiral.l1preproc.Hemispheres

Bases: enum.StrEnum

Enum for hemispheres.

NORTH = 'nh'

SOUTH = 'sh'

GLOBAL = 'global'

classmethod get_choices() → List[str]

class pysiral.l1preproc.L1bDataNC

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

Class to export a L1bdata object into a netcdf file NOTE: This class is different from the other netCDF output classes as

it uses data groups.

datagroups = ['waveform', 'surface_type', 'time_orbit', 'classifier', 'correction']

filename = None

time_def

zlib = True

_rootgrp = None

_options = None

_proc_settings = None

verbose = False

output_folder = None

l1b = None

parameter_attributes = []

export()

_validate()

_create_filename()

_set_global_attributes(attdict, prefix=''): Save l1b.info dictionary as global attributes

_create_root_group(attdict, **global_attr_keyw): Create the root group and add l1b metadata as global attributes :param attdict: A dictionary containing the global attributes :param global_attr_keyw: :return:

_populate_data_groups()

_convert_datetime_attributes(attdict): Change any datetime-like object to a netCDF compatible numerical representation :param attdict: dictionary-like :return:

static _convert_bool_attributes(attdict): Replace l1b info parameters of type bool [‘b1’] by a integer representation to match requirements for netCDF attribute data type rules :param attdict: dictionary-like :return:

static _convert_nonetype_attributes(attdict): Change empty (None) values in an attrdict to an empty string :param attdict: dictionary like :return: None, will be changed in place

_get_variable_attr_dict(parameter): Retrieve the parameter attributes

_open_file()

_write_to_file()

class pysiral.l1preproc.L1bMetaData

Bases: object

Container for L1B Metadata information (see property attribute_list for a list of attributes)

_attribute_list = ['pysiral_version', 'mission', 'mission_data_version', 'mission_sensor', 'mission_data_source',...

_attrs

__repr__()

__getattr__(item): Modify the attribute getter to provide a shortcut to the data content :param item: Name of the parameter :return:

property attribute_list

property attdict: Return attributes as dictionary (e.g. for netCDF export)

property hemisphere

property year

property month

set_attribute(tag, value)

check_n_records(n_records: int) → None

First time a data set is set: Store number of records as reference

Parameters:: n_records – Number of records
Returns:: None
Raises:: ValueError

class pysiral.l1preproc.Level1bData

Bases: object

Unified L1b Data Class

data_groups = ['time_orbit', 'correction', 'classifier', 'waveform', 'surface_type']

info

waveform

time_orbit

correction

classifier

surface_type

append(l1b_annex: Level1bData, remove_overlap: bool = False, warn_if_temporal_offset_seconds: int = 10, raise_on_error: bool = False) → None

Appends another l1b object to this one. The l1b_annex object is expected to have data after the self instance.

Parameters:

l1b_annex – The Level-1B dataset to be appended
remove_overlap – Trim the appending L1 object in case of temporal overlap
warn_if_temporal_offset_seconds
raise_on_error – Raise an exception if the appending process fails, otherwise an error is logged and the appending is skipped

Returns:

None, current L1 object is changed in-place

trim_to_subset(subset_list: List | numpy.typing.NDArray) → None: Create a subset from an index list

apply_range_correction(correction): Apply range correction

extract_subset(subset_list): Same as trim_to_subset, except returns a new l1bdata instance

extract_region_of_interest(roi): Extracts data for a given region of interest definition

detect_and_fill_gaps(gap_tolerance=0.02): Some radar altimeter input products are not provided with a regular time/sample spacing, e.g. by omitting short sections of the along-track data. This method is supposed to rectify that by 1. Compute the nominal data repitition rate (in seconds) 2. Detect gaps in the timestamp value 3. Fills all arrays in all data groups with empty values

(no interpolation)

update_l1b_metadata()

update_data_limit_attributes(): Set latitude/longitude and timestamp limits in the metadata container

update_waveform_statistics(): Compute waveform metadata attributes

update_surface_type_statistics(): Re-calculate the open ocean percent

update_region_name(): Estimate the region (north/south/global) for metatdata class

reduce_waveform_bin_count(target_count: int, maxloc: float = 0.4) → None

Reduce the bin count of waveform power and range arrays. (e.g. for merging CryoSat-2 SAR [256 bins] and SIN [1024 bins])

Creates a subset and updates the l1b.waveform container

Parameters:

target_count – target number of waveform bins (needs to be smaller than full waveform bin count)
maxloc – preferred location of the maximum of the waveform in the subset

Raises:

None –

Returns:

None

increase_waveform_bin_count(target_count: int) → None

Increase the bin count of waveform power and range arrays. (e.g. for merging CryoSat-2 LRM [128 bins] and SAR [256 bins])

Creates a subset and updates the l1b.waveform container

Parameters:: target_count – target number of waveform bins (needs to be bigger than full waveform bin count)
Raises:: None –
Returns:: None

get_parameter_by_name(data_group: str, parameter_name: str) → None | numpy.ndarray

API method to retrieve any parameter from any data group

Parameters:

data_group
parameter_name

Returns:

set_parameter_by_name(data_group_name: str, parameter_name: str, value: numpy.ndarray) → None: API method to set any parameter in any data group

property n_records: int

property tcs: datetime.datetime

property tce: datetime.datetime

property radar_modes

class pysiral.l1preproc.L1PProcItemDef(label: str, stage: str, module_name: str, class_name: str, options_dict: dict = None)

Bases: object

Class for validating and processing Level-1 Pre-Processor item definition

label

stage

module_name

class_name

option_dict

classmethod from_l1procdef_dict(procdef_dict: dict | pysiral.core.legacy_classes.AttrDict) → L1PProcItemDef: Initialize the class from the corresponding excerpt of the Level-1 processor configuration file. :param procdef_dict: :return:

get_initialized_processing_item_instance() → L1PPROCITEM_CLS_TYPE

Return an inialized instance of the processor item described by this configuration class

Returns:: descendent of L1PProcItem

property valid_stages

pysiral.l1preproc.SHOW_DEBUG_MAP = False

pysiral.l1preproc.L1P_HEMISPHERE_NAMING_DICT

class pysiral.l1preproc.Level1PInputHandlerBase(cfg: pysiral.core.legacy_classes.AttrDict, raise_on_error: bool = False, cls_name: str = None)

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

Base class (mostly for type checking).

error

cfg

raise_on_error = False

abstractmethod get_l1(filepath: pathlib.Path, **kwargs) → None | pysiral.l1data.Level1bData

This method needs to be overwritten by inherting class.

Parameters:: filepath
Returns:

class pysiral.l1preproc.Level1POutputHandler(cfg: pysiral.core.legacy_classes.AttrDict)

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

The output handler for l1p product files NOTE: This is not a subclass of OutputHandlerbase due to the special nature of pysiral l1p products

error

cfg

pysiral_cfg

_path = None

_filename = None

static remove_old_if_applicable(perid: dateperiods.DatePeriod) → None

export_to_netcdf(l1: pysiral.l1data.Level1bData) → None

Workflow to export a Level-1 object to l1p netCDF product. The workflow includes the generation of the output path (if applicable).

Parameters:: l1 – The Level-1 object to be exported
Returns:: None

set_output_filepath(l1: pysiral.l1data.Level1bData) → None

Sets the class properties required for the file export

Parameters:: l1 – The Level-1 object
Returns:: None

property path: pathlib.Path

property filename: str

property last_written_file: pathlib.Path

pysiral.l1preproc.L1PInputCLS

class pysiral.l1preproc.L1PreProcBase(cls_name: str, input_adapter: L1PInputCLS, output_handler: Level1POutputHandler, cfg: pysiral.core.legacy_classes.AttrDict)

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

Template for default pysiral class with logging/error handling capabilities

error

input_adapter

output_handler

cfg

processor_item_dict

_init_processor_items() → None

Popuplate the processor item dictionary with initialized processor item classes for the different stages of the Level-1 pre-processor.

This method will evaluate the configuration dictionary passed to this class, retrieve the corresponding classes, initialize them and store in a dictionary.

Dictionary entries are the names of the processing stages and the content is a list of classes (cls, label) per processing stage.

Returns:

process_input_files(input_file_list: List[pathlib.Path | str]) → None

Main entry point for the Level-1 pre-processor and start of the main loop of this class:

Sequentially reads source file from input list of source files
Applies processing items (stage: post_source_file)
Extract polar ocean segments (can be multiple per source file)
Applies processing items (stage: post_polar_ocean_segment_extraction)
Creates a stack of spatially connecting segments a. if this includes all segments of the source file the loop

progresses to the next source file
1. if the stack contains a spatially unconnected segments
  1. merge all connected segments to a single l1 object
  2. Applies processing items (stage: post_merge)
  3. Export to l1p netCDF
Export the last l1p segment at the end of the loop.

Parameters:: input_file_list – A list full filepath for the pre-processor
Returns:: None

abstractmethod extract_polar_ocean_segments(l1: pysiral.l1data.Level1bData) → List[pysiral.l1data.Level1bData]

Needs to be implemented by child classes, because the exact algorithm depends on th source data.

Parameters:: l1
Returns:: None
Raises:: NotImplementedError

l1_apply_processor_items(l1: pysiral.l1data.Level1bData | List[pysiral.l1data.Level1bData], stage_name: str) → None

Apply the processor items defined in the l1 processor configuration file to either a l1 data object or a list of l2 data objects at a defined stage of the procesor.

This method is a wrapper that deals with multiple input types. The functionality is implemented in _l1_apply_proc_item

Parameters:

l1 – Level-1 data object or list of Level-1 data objects
stage_name – Name of the processing stage. Valid options are (post_source_file, post_ocean_segment_extraction, post_merge)

Returns:

None, the l1_segments are changed in place

_l1_apply_proc_item_list(l1_list: List[pysiral.l1data.Level1bData], stage_name: str) → None

Apply processor item to full stack

Parameters:

l1_list
stage_name

Returns:

_l1_apply_proc_item(l1_item: pysiral.l1data.Level1bData, stage_name: str) → None

Apply a list of

Parameters:

l1_item
stage_name

Returns:

l1_get_output_segments(l1_connected_stack: List[pysiral.l1data.Level1bData], l1_po_segments: List[pysiral.l1data.Level1bData]) → Tuple[List[pysiral.l1data.Level1bData], List[pysiral.l1data.Level1bData]]

This method sorts the stack of connected l1 segments and the polar ocean segments of the most recent file and sorts the segments into (connected) output and the new stack, defined by the last (connected) item.

Parameters:

l1_connected_stack – List of connected L1 polar ocean segments (from previous file(s))
l1_po_segments – List of L1 polar ocean segments (from current file)

Returns:

L1 segments for the ouput, New l1 stack of connected items

static l1_split_radar_mode_segments(l1_list: List[pysiral.l1data.Level1bData]) → List[pysiral.l1data.Level1bData]

This method checks if there is more than one radar mode per l1 segment and splits the segments for each radar mode change. This is done, because multiple radar modes per segment may be problematic for Level-1 pre-processor items. The final l1p output file may contain multiple radar modes.

NOTE: So far this is only needed for the Sentinel-3A/B L2 thematic sea ice product.: No other files have been found so far that have more than one radar mode.

Parameters:: l1_list – Input list of l1 segments.
Returns:: l1_output_list: Output list of l1 segments with single radar mode

l1_are_connected(l1_0: pysiral.l1data.Level1bData, l1_1: pysiral.l1data.Level1bData) → bool

Check if the start time of l1 segment 1 and the stop time of l1 segment 0 indicate neighbouring orbit segments. -> Assumes explicetly that l1_0 comes before l1_1

Parameters:

l1_0
l1_1

Returns:

Flag if l1 segments are connected (True of False)

l1_export_to_netcdf(l1: pysiral.l1data.Level1bData) → None

Exports the Level-1 object as l1p netCDF

Parameters:: l1 – The Level-1 object to exported
Returns:

trim_single_hemisphere_segment_to_polar_region(l1: pysiral.l1data.Level1bData) → pysiral.l1data.Level1bData

Extract polar region of interest from a segment that is either north or south (not global)

Parameters:: l1 – Input Level-1 object
Returns:: Trimmed Input Level-1 object

trim_two_hemisphere_segment_to_polar_regions(l1: pysiral.l1data.Level1bData) → None | List[pysiral.l1data.Level1bData]

Extract polar regions of interest from a segment that is either north, south or both. The method will preserve the order of the hemispheres

Parameters:: l1 – Input Level-1 object
Returns:: List of Trimmed Input Level-1 objects

trim_multiple_hemisphere_segment_to_polar_regions(l1: pysiral.l1data.Level1bData) → None | List[pysiral.l1data.Level1bData]

Extract polar regions segments from an orbit segment that may cross from north to south to north again (or vice versa).

Parameters:: l1 – Input Level-1 object
Returns:: List of Trimmed Input Level-1 objects

trim_full_orbit_segment_to_polar_regions(l1: pysiral.l1data.Level1bData) → None | List[pysiral.l1data.Level1bData]

Extract polar regions of interest from a segment that is either north, south or both. The method will preserve the order of the hemispheres

Parameters:: l1 – Input Level-1 object
Returns:: List of Trimmed Input Level-1 objects

filter_small_ocean_segments(l1: pysiral.l1data.Level1bData) → pysiral.l1data.Level1bData

This method sets the surface type flag of very small ocean segments to land. This action should prevent large portions of land staying in the l1 segment is a small fjord et cetera is crossed. It should also filter out smaller ocean segments that do not have a realistic chance of freeboard retrieval.

Parameters:: l1 – A pysiral.l1bdata.Level1bData instance
Returns:: filtered l1 object

static trim_non_ocean_data(l1: pysiral.l1data.Level1bData) → None | pysiral.l1data.Level1bData

Remove leading and trailing data that is not if type ocean.

Parameters:: l1 – The input Level-1 objects
Returns:: The subsetted Level-1 objects. (Segments with no ocean data are removed from the list)

split_at_large_non_ocean_segments(l1: pysiral.l1data.Level1bData) → List[pysiral.l1data.Level1bData]

Identify larger segments that are not ocean (land, land ice) and split the segments if necessary. The return value will always be a list of Level-1 object instances, even if no non-ocean data segment is present in the input data file

Parameters:: l1 – Input Level-1 object
Returns:: a list of Level-1 objects.

split_at_time_discontinuities(l1_list: List[pysiral.l1data.Level1bData]) → List[pysiral.l1data.Level1bData]

Split l1 object(s) at discontinuities of the timestamp value and return the expanded list with l1 segments.

Parameters:: l1_list – [list] a list of l1b_files
Returns:: expanded list

property polar_ocean_props: Dict | pysiral.core.legacy_classes.AttrDict

property orbit_segment_connectivity_props: Dict | pysiral.core.legacy_classes.AttrDict

class pysiral.l1preproc.L1PreProcCustomOrbitSegment(*args)

Bases: L1PreProcBase

A Pre-Processor for input files with arbitrary segment lenght (e.g. CryoSat-2)

extract_polar_ocean_segments(l1: pysiral.l1data.Level1bData) → List[pysiral.l1data.Level1bData]

Splits the input Level-1 object into the polar ocean segments (e.g. by trimming land at the edges or by splitting into several parts if there are land masses with the orbit segment). The returned polar ocean segments should be generally free of data over non-ocean parts of the orbit, except for smaller parts within the orbit.

NOTE: This subclass of the Level-1 Pre-Processor is designed for input data type with arbitrary: orbit segment length (e.g. data of CryoSat-2 where the orbit segments of the input data is controlled by the mode mask changes).

Parameters:: l1 – A Level-1 data object
Returns:: A list of Level-1 data objects (subsets of polar ocean segments from input l1)

class pysiral.l1preproc.L1PreProcHalfOrbit(*args)

Bases: L1PreProcBase

A Pre-Processor for input files with a full orbit around the earth (e.g. ERS-1/2)

extract_polar_ocean_segments(l1: pysiral.l1data.Level1bData) → List[pysiral.l1data.Level1bData]

Splits the input Level-1 object into the polar ocean segments (e.g. by trimming land at the edges or by splitting into several parts if there are land masses with the orbit segment). The returned polar ocean segments should be generally free of data over non-ocean parts of the orbit, except for smaller parts within the orbit.

NOTE: This subclass of the Level-1 Pre-Processor is designed for input data type with coverage: from pole to pole (e.g. Envisat SGDR)

Parameters:: l1 – A Level-1 data object
Returns:: A list of Level-1 data objects (subsets of polar ocean segments from input l1)

class pysiral.l1preproc.L1PreProcFullOrbit(*args)

Bases: L1PreProcBase

A Pre-Processor for input files with a full orbit around the earth (e.g. ERS-1/2)

extract_polar_ocean_segments(l1: pysiral.l1data.Level1bData) → List[pysiral.l1data.Level1bData]

Splits the input Level-1 object into the polar ocean segments (e.g. by trimming land at the edges or by splitting into several parts if there are land masses with the orbit segment). The returned polar ocean segments should be generally free of data over non-ocean parts of the orbit, except for smaller parts within the orbit.

NOTE: This subclass of the Level-1 Pre-Processor is designed for input data type with arbitrary: orbit segment length (e.g. data of CryoSat-2 where the orbit segments of the input data is controlled by the mode mask changes).

Parameters:: l1 – A Level-1 data object
Returns:: A list of Level-1 data objects (subsets of polar ocean segments from input l1)

class pysiral.l1preproc.L1PreProcPolarOceanCheck(log_name: str, cfg: pysiral.core.legacy_classes.AttrDict)

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

A small helper class that can be passed to input adapter to check whether the l1 segment is wanted or not

error

cfg

has_polar_ocean_segments(product_metadata: pysiral.l1data.L1bMetaData) → bool: Checks if there are polar oceans segments based on the metadata of a L1 data object :param product_metadata: Metadata container of the l1b data product. :return: Boolean Flag (true: in region of interest, false: not in region of interest)

class pysiral.l1preproc.Level1PreProcJobDef(l1p_settings_id_or_file: str | pathlib.Path, processing_period: dateperiods.DatePeriod, exclude_month: List[int] = None, hemisphere: pysiral.core.flags.Hemispheres = Hemispheres.GLOBAL, platform: str = None, output_handler_cfg: dict | pysiral.core.legacy_classes.AttrDict = None, source_repo_id: str | None = None)

Bases: pysiral.core.legacy_classes.DefaultLoggingClass

A class that contains all information necessary for the Level-1 pre-processor.

error

_l1pprocdef = None

_hemisphere

_platform = None

_source_repo_id = None

_exclude_month = None

_time_range

_output_handler_cfg = None

stopwatch

classmethod from_args(args: pysiral.core.legacy_classes.AttrDict) → Level1PreProcJobDef

Init the Processor Definition from the pysiral-l1preproc command line argument object

Parameters:: args
Returns:

_set_l1p_processor_def(l1p_settings_id_or_file: str | pathlib.Path) → None

Parse the content of the processor definition file

Parameters:: l1p_settings_id_or_file – A pysiral known id or list
Returns:

_get_l1p_proc_def_filename(l1p_settings_id_or_file: str | pathlib.Path) → str | pathlib.Path

Query pysiral config to obtain filename for processor definition file

Parameters:: l1p_settings_id_or_file
Returns:: The full file path

_get_local_input_directory() → None: Replace the tag for local machine def with the actual path info

_check_if_unambiguous_platform() → None

Checks if the platform is unique, since some l1 processor definitions are valid for a series of platforms, such as ERS-1/2, Sentinel-3A/B, etc. The indicator is that the platform tag in the l1 preprocessor settings is comma separated list.

For the location of the source data, it is however necessary that the exact platform is known. It must therefore be specified explicitly by the -platform argument

Raises:: SysExit –

property hemisphere: str

property target_hemisphere: List[str]

Get the list of target hemisphere names for the l1p processor definition. Global here refers to both polar regions, with the latitude range defined by the polar_latitude_threshold option in the l1p processor definition.

Returns:: List of hemisphere names for the l1p processor definition

property l1pprocdef: pysiral.core.legacy_classes.AttrDict

property time_range: dateperiods.DatePeriod

property period_segments: dateperiods.PeriodIterator

property output_handler_cfg: pysiral.core.legacy_classes.AttrDict

property platform: str

pysiral.l1preproc.L1PPROC_CLS_TYPE

pysiral.l1preproc.get_preproc(preproc_type: str, input_adapter: L1PInputCLS, output_handler: Level1POutputHandler, cfg: pysiral.core.legacy_classes.AttrDict) → L1PPROC_CLS_TYPE

A function returning the pre-processor class corresponding the type definition.

Parameters:

preproc_type – type of the pre-processor
input_adapter – A class that return a L1bData object for a given input product file
output_handler – A class that creates a pysiral l1p product from the merged L1bData object
cfg – options for the pre-processor

Returns:

Initialized pre-processor class

pysiral.l1preproc.l1p_debug_map(l1p_list: List[pysiral.l1data.Level1bData], title: str = None) → None

Create an interactive map of l1p segment

Parameters:

l1p_list
title

Returns: