icepyx

Python tools for obtaining and working with ICESat-2 data

icepyx is both a software library and a community composed of ICESat-2 data users, developers, and the scientific community. We are working together to develop a shared library of resources - including existing resources, new code, tutorials, and use-cases/examples - that simplify the process of querying, obtaining, analyzing, and manipulating ICESat-2 datasets to enable scientific discovery.

Origin and Purpose

icepyx is both a software library and a community composed of ICESat-2 data users, developers, and the scientific community. We are working together to develop a shared library of resources - including existing resources, new code, tutorials, and use-cases/examples - that simplify the process of querying, obtaining, analyzing, and manipulating ICESat-2 datasets to enable scientific discovery.

icepyx aims to provide a clearinghouse for code, functionality to improve interoperability, documentation, examples, and educational resources that tackle disciplinary research questions while minimizing the amount of repeated effort across groups utilizing similar datasets. icepyx also hopes to foster collaboration, open-science, and reproducible workflows by integrating and sharing resources.

Many of the underlying tools from which icepyx was developed began as Jupyter Notebooks developed for and during the cryosphere-themed ICESat-2 Hackweek at the University of Washington in June 2019 or as scripts written and used by the ICESat-2 Science Team members. This project combines and generalizes these scripts into a unified framework, adding examples, documentation, and testing where necessary and making them accessible for everyone. It also improves interoperability for ICESat-2 datasets with other open-source tools. Our resources guide provides additional information on both the foundational documents for icepyx and closely related libraries for working with ICESat-2 data.

Installation

The simplest way to install icepyx is using pip.

pip install icepyx

Windows users will need to first install Fiona, please look at the instructions there. Windows users may consider installing Fiona using pipwin

pip install pipwin
pipwin install Fiona

Currently, updated packages are not automatically generated with each build. This means it is possible that pip will not install the latest release of icepyx. In this case, icepyx is also available for use via the GitHub repository. The contents of the repository can be download as a zipped file or cloned.

To use icepyx this way, fork this repo to your own account, then git clone the repo onto your system. To clone the repository:

git clone https://github.com/icesat2py/icepyx.git

Provided the location of the repo is part of your $PYTHONPATH, you should simply be able to add import icepyx to your Python document. Alternatively, in a command line or terminal, navigate to the folder in your cloned repository containing setup.py and run

pip install -e

Future developments of icepyx may include conda as another simplified installation option.

Citation Information

icepyx

This community and software is developed with the goal of supporting science applications. Thus, our contributors (including those who have developed the packages used within icepyx) and maintainers justify their efforts and demonstrate the impact of their work through citations.

If you have used icepyx in your work, please consider citing our library:

Scheick, J. et al., (2019). icepyx: Python tools for obtaining and working with ICESat-2 data. https://github.com/icesat2py/icepyx.

A bibtex version for users working in Latex:

  @Misc{icepyx,
author =    {Scheick, Jessica and others},
organization = {icesat2py},
title =     {{icepyx: Python} tools for obtaining and working with {ICESat-2} data},
year =      {2019--},
url = "https://github.com/icesat2py/icepyx"
  }

icepyx Dependencies

If you have used one of the included packages to extend your data analysis capabilities within icepyx, please consider additionally citing that work, because it represents an independent software contribution to the open-source community. SciPy provides a helpful resource for citing packages within the SciPy ecosystem (including Matplotlib, NumPy, pandas, and SciPy). Links to citation information for other commonly used packages are below.

ICESat-2 Data

ICESat-2 data citation depends on the exact dataset used. Citation information for each data product can be found through the NSIDC website.

icepyx Documentation (API Reference)

PlantUML Class Diagram illustrating the public-facing classes within icepyx, their attributes and methods, their relationships (e.g. component classes).

icepyx class diagram illustrating the library’s public-facing classes, their attributes and methods, and their relationships.

Query Class

Constructor

Query([dataset, spatial_extent, date_range, …])

ICESat-2 Data object to query, obtain, and perform basic operations on available ICESat-2 datasets using temporal and spatial input parameters.

Attributes

Query.CMRparams

Display the CMR key:value pairs that will be submitted.

Query.cycles

Return the unique ICESat-2 orbital cycle.

Query.dataset

Return the short name dataset ID string associated with the query object.

Query.dataset_version

Return the dataset version of the data object.

Query.dates

Return an array showing the date range of the query object.

Query.end_time

Return the end time specified for the end date.

Query.file_vars

Return the file variables object.

Query.granules

Return the granules object, which provides the underlying funtionality for searching, ordering, and downloading granules for the specified dataset.

Query.orbit_number

Return the ICESat-2 CMR orbit number

Query.order_vars

Return the order variables object.

Query.reqparams

Display the required key:value pairs that will be submitted.

Query.spatial_extent

Return an array showing the spatial extent of the query object.

Query.subsetparams(**kwargs)

Display the subsetting key:value pairs that will be submitted.

Query.start_time

Return the start time specified for the start date.

Query.tracks

Return the unique ICESat-2 Reference Ground Tracks

Methods

Query.avail_granules([ids, cycles, tracks])

Obtain information about the available granules for the query object’s parameters.

Query.dataset_all_info()

Display all metadata about the dataset of interest (the collection).

Query.dataset_summary_info()

Display a summary of selected metadata for the specified version of the dataset of interest (the collection).

Query.download_granules(path[, verbose, …])

Downloads the data ordered using order_granules.

Query.earthdata_login(uid, email)

Log in to NSIDC EarthData to access data.

Query.latest_version()

Determine the most recent version available for the given dataset.

Query.order_granules([verbose, subset, email])

Place an order for the available granules for the query object.

Query.show_custom_options([dictview])

Display customization/subsetting options available for this dataset.

Query.visualize_spatial_extent()

Creates a map displaying the input spatial extent

Query Components

APIformatting

class icepyx.core.APIformatting.Parameters(partype, values=None, reqtype=None)

Bases: object

Build and update the parameter lists needed to submit a data order

Parameters
partypestring

Type of parameter list. Must be one of [‘CMR’,’required’,’subset’]

valuesdictionary, default None

Dictionary of already-formatted parameters, if there are any, to avoid re-creating them.

reqtypestring, default None

For partype==’required’, indicates which parameters are required based on the type of query. Must be one of [‘search’,’download’]

build_params(**kwargs)

Build the parameter dictionary of formatted key:value pairs for submission to NSIDC in the data request.

Parameters
**kwargs

Keyword inputs containing the needed information to build the parameter list, depending on parameter type, if the already formatted key:value is not submitted as a kwarg. May include optional keyword arguments to be passed to the subsetter. Valid keywords are time, bbox OR Boundingshape, format, projection, projection_parameters, and Coverage.

Keyword argument inputs for ‘CMR’ may include: dataset, version, start, end, extent_type, spatial_extent Keyword argument inputs for ‘required’ may include: page_size, page_num, request_mode, include_meta Keyword argument inputs for ‘subset’ may include: geom_filepath, start, end, extent_type, spatial_extent

check_req_values()

Check that all of the required keys have values, if the key was passed in with the values parameter.

check_values()

Check that the non-required keys have values, if the key was passed in with the values parameter.

property fmted_keys

Returns the dictionary of formated keys associated with the parameter object.

property poss_keys

Returns a list of possible input keys for the given parameter object. Possible input keys depend on the parameter type (partype).

icepyx.core.APIformatting.combine_params(*param_dicts)

Combine multiple dictionaries into one.

Parameters
paramsdictionaries

Unlimited number of dictionaries to combine

Returns
single dictionary of all input dictionaries combined

Examples

>>> CMRparams = {'short_name': 'ATL06', 'version': '002', 'temporal': '2019-02-20T00:00:00Z,2019-02-28T23:59:59Z', 'bounding_box': '-55,68,-48,71'}
>>> reqparams = {'page_size': 10, 'page_num': 1}
>>> icepyx.core.APIformatting.combine_params(CMRparams, reqparams)
{'short_name': 'ATL06',
'version': '002',
'temporal': '2019-02-20T00:00:00Z,2019-02-28T23:59:59Z',
'bounding_box': '-55,68,-48,71',
'page_size': 10,
'page_num': 1}

Earthdata

class icepyx.core.Earthdata.Earthdata(uid, email, capability_url, pswd=None)

Bases: object

Initiate an Earthdata session for interacting with the NSIDC DAAC.

Parameters
uidstring

Earthdata Login user name (user ID).

emailstring

Complete email address, provided as a string.

passwordstring (encrypted)

Password for Earthdata registration associated with the uid.

capability_urlstring

URL required to access Earthdata

Returns
Earthdata session object after a successful login
login()

This function tries to log the user in to Earthdata with the information provided. It prompts the user for their Earthdata password, but will only store that information within the active session. If the login fails, it will ask the user to re-enter their username and password up to five times to try and log in.

Alternatively, you can create a .netrc file in your $HOME directory with the following line:

machine urs.earthdata.nasa.gov login <uid> password <password>

Where <uid> is your NASA Earthdata user ID and <password> is your password Then change the permissions of that file to 600 This will allow you to have read and write access to the file No other user can access the file

$ chmod 600 ~/.netrc

The function checks for this file to retrieve credentials, prior to prompting for manual input.

Examples

>>> icepyx.core.Earthdata.Earthdata.login('sam.smith','sam.smith@domain.com')
Earthdata Login password:  ········

geospatial

icepyx.core.geospatial.geodataframe(extent_type, spatial_extent, file=False)

Return a geodataframe of the spatial extent

Parameters
extent_typestring

One of ‘bounding_box’ or ‘polygon’, indicating what type of input the spatial extent is

spatial_extentstring

A string of the spatial extent. If file is False, the string should be a list of coordinates in decimal degrees of [lower-left-longitude, lower-left-latitute, upper-right-longitude, upper-right-latitude] or [longitude1, latitude1, longitude2, latitude2, … longitude_n,latitude_n, longitude1,latitude1]. If file is True, the string is the full file path and filename to the file containing the desired spatial extent.

fileboolean, default False

Indication for whether the spatial_extent string is a filename or coordinate list

See also

icepyx.Query

Examples

>>> reg_a = icepyx.Query('ATL06',[-55, 68, -48, 71],['2019-02-20','2019-02-28'])
>>> gdf = geospatial.geodataframe(reg_a.extent_type, reg_a._spat_extent)
>>> gdf.geometry
0    POLYGON ((-55.00000 68.00000, -55.00000 71.000...
Name: geometry, dtype: geometry

granules

class icepyx.core.granules.Granules

Bases: object

Interact with ICESat-2 data granules. This includes finding, ordering, and downloading them as well as (not yet implemented) getting already downloaded granules into the query object.

Returns
Granules object
download(verbose, path, session=None, restart=False)

Downloads the data for the object’s orderIDs, which are generated by ordering data from the NSIDC.

Parameters
verboseboolean, default False

Print out all feedback available from the order process. Progress information is automatically printed regardless of the value of verbose.

pathstring

String with complete path to desired download directory and location.

sessionrequests.session object

A session object authenticating the user to download data using their Earthdata login information. The session object will automatically be passed from the query object if you have successfully logged in there.

restartboolean, default False

Restart your download if it has been interrupted. If the kernel has been restarted, but you successfully completed your order, you will need to re-initialize your query class object and log in to Earthdata and can then skip immediately to the download_granules method with restart=True.

See also

query.Query.download_granules

Notes

This function is used by query.Query.download_granules(), which automatically feeds in the required parameters.

get_avail(CMRparams, reqparams)

Get a list of available granules for the query object’s parameters. Generates the avail attribute of the granules object.

Parameters
CMRparamsdictionary

Dictionary of properly formatted CMR search parameters.

reqparamsdictionary

Dictionary of properly formatted parameters required for searching, ordering, or downloading from NSIDC.

See also

APIformatting.Parameters
query.Query.avail_granules

Notes

This function is used by query.Query.avail_granules(), which automatically feeds in the required parameters.

place_order(CMRparams, reqparams, subsetparams, verbose, subset=True, session=None, geom_filepath=None)

Place an order for the available granules for the query object. Adds the list of zipped files (orders) to the granules data object (which is stored as the granules attribute of the query object). You must be logged in to Earthdata to use this function.

Parameters
CMRparamsdictionary

Dictionary of properly formatted CMR search parameters.

reqparamsdictionary

Dictionary of properly formatted parameters required for searching, ordering, or downloading from NSIDC.

subsetparamsdictionary

Dictionary of properly formatted subsetting parameters. An empty dictionary is passed as input here when subsetting is set to False in query methods.

verboseboolean, default False

Print out all feedback available from the order process. Progress information is automatically printed regardless of the value of verbose.

subsetboolean, default True

Apply subsetting to the data order from the NSIDC, returning only data that meets the subset parameters. Spatial and temporal subsetting based on the input parameters happens by default when subset=True, but additional subsetting options are available. Spatial subsetting returns all data that are within the area of interest (but not complete granules. This eliminates false-positive granules returned by the metadata-level search)

sessionrequests.session object

A session object authenticating the user to order data using their Earthdata login information. The session object will automatically be passed from the query object if you have successfully logged in there.

geom_filepathstring, default None

String of the full filename and path when the spatial input is a file.

See also

query.Query.order_granules

Notes

This function is used by query.Query.order_granules(), which automatically feeds in the required parameters.

icepyx.core.granules.gran_IDs(grans, ids=True, cycles=False, tracks=False)

Returns a list of granule information for the granule dictionary. Granule info may be from a list of those available from NSIDC (for ordering/download) or a list of granules present on the file system.

Parameters
ids: boolean, default True

Return a list of the available granule IDs for the granule dictionary

cyclesboolean, default False

Return a list of the available orbital cycles for the granule dictionary

tracksboolean, default Fal

Return a list of the available Reference Ground Tracks (RGTs) for the granule dictionary

icepyx.core.granules.info(grans)

Return some basic summary information about a set of granules for an query object. Granule info may be from a list of those available from NSIDC (for ordering/download) or a list of granules present on the file system.

is2ref

icepyx.core.is2ref.about_dataset(dset)

Ping Earthdata to get metadata about the dataset of interest (the collection).

See also

query.Query.dataset_all_info

validate_inputs

icepyx.core.validate_inputs.cycles(all_cycles, cycles)

Check if the submitted cycle is valid, and warn the user if not available.

icepyx.core.validate_inputs.dset_version(latest_vers, version)

Check if the submitted dataset version is valid, and warn the user if a newer version is available.

icepyx.core.validate_inputs.spatial(spatial_extent)

Validate the input spatial extent and return the needed parameters to the query object.

icepyx.core.validate_inputs.temporal(date_range, start_time, end_time)

Validate the input temporal parameters and return the needed parameters to the query object.

icepyx.core.validate_inputs.tracks(all_tracks, tracks)

Check if the submitted RGT is valid, and warn the user if not available.

variables

class icepyx.core.variables.Variables(vartype, avail=None, wanted=None, session=None, dataset=None, version=None, source=None)

Bases: object

Get, create, interact, and manipulate lists of variables and variable paths contained in ICESat-2 datasets.

Parameters
vartypestring

One of [‘order’, ‘file’] to indicate the source of the input variables. This field will be auto-populated when a variable object is created as an attribute of a query object.

availdictionary, default None

Dictionary (key:values) of available variable names (keys) and paths (values).

wanteddictionary, default None

As avail, but for the desired list of variables

sessionrequests.session object

A session object authenticating the user to download data using their Earthdata login information. The session object will automatically be passed from the query object if you have successfully logged in there.

datasetstring, default None

Properly formatted string specifying a valid ICESat-2 dataset

versionstring, default None

Properly formatted string specifying a valid version of the ICESat-2 dataset

sourcestring, default None

For vartype file, a path to a directory or single input source files (not yet implemented)

append(defaults=False, var_list=None, beam_list=None, keyword_list=None)

Add to the list of desired variables using user specified beams and variable list. A pregenerated default variable list can be used by setting defaults to True. Note: The calibrated backscatter cab_prof is not in the default list for ATL09

Parameters
defaultsboolean, default False

Include the variables in the default variable list. Defaults are defined per-data product. When specified in conjuction with a var_list, default variables not on the user- specified list will be added to the order.

var_listlist of strings, default None

A list of variables to request, if not all available variables are wanted. A list of available variables can be obtained by entering var_list=[‘’] into the function.

beam_listlist of strings, default None

A list of beam strings, if only selected beams are wanted (the default value of None will automatically include all beams). For ATL09, acceptable values are [‘profile_1’, ‘profile_2’, ‘profile_3’]. For all other datasets, acceptable values are [‘gt1l’, ‘gt1r’, ‘gt2l’, ‘gt2r’, ‘gt3l’, ‘gt3r’].

keyword_listlist of strings, default None

A list of subdirectory names (keywords), from any heirarchy level within the data structure, to select variables within the dataset that include that keyword in their path. A list of availble keywords can be obtained by entering keyword_list=[‘’] into the function.

Notes

See also the ICESat-2_DAAC_DataAccess2_Subsetting example notebook

Examples

>>> reg_a = icepyx.query.Query('ATL06',[-55, 68, -48, 71],['2019-02-20','2019-02-28'])
>>> reg_a.earthdata_login(user_id,user_email)
Earthdata Login password:  ········

To add all variables related to a specific ICESat-2 beam

>>> reg_a.order_vars.append(beam_list=['gt1r'])

To include the default variables:

>>> reg_a.order_vars.append(defaults=True)

To add specific variables in orbit_info

>>> reg_a.order_vars.append(keyword_list=['orbit_info'],var_list=['sc_orient_time'])

To add all variables and paths in ancillary_data

>>> reg_a.order_vars.append(keyword_list=['ancillary_data'])
avail(options=False, internal=False)

Get the list of available variables and variable paths from the input dataset

[‘ancillary_data/atlas_sdp_gps_epoch’,

‘ancillary_data/control’, ‘ancillary_data/data_end_utc’, ‘ancillary_data/data_start_utc’, . . . ‘quality_assessment/gt3r/signal_selection_source_fraction_3’]

static parse_var_list(varlist)

Parse a list of path strings into tiered lists and names of variables

‘geophysical’, ‘ground_track’, ‘gt1l’, ‘gt1r’, ‘gt2l’, ‘gt2r’, ‘gt3l’, ‘gt3r’, ‘land_ice’, ‘land_ice_segments’, ‘none’, ‘orbit_info’, ‘quality_assessment’, ‘residual_histogram’, ‘segment_quality’, ‘signal_selection_status’], dtype=’<U23’)

remove(all=False, var_list=None, beam_list=None, keyword_list=None)
Remove the variables and paths from the wanted list using user specified beam, keyword,

and variable lists.

Notes

See also the ICESat-2_DAAC_DataAccess2_Subsetting example notebook

Examples

>>> reg_a = icepyx.query.Query('ATL06',[-55, 68, -48, 71],['2019-02-20','2019-02-28'])
>>> reg_a.earthdata_login(user_id,user_email)
Earthdata Login password:  ········

To clear the list of wanted variables

>>> reg_a.order_vars.remove(all=True)

To remove all variables related to a specific ICESat-2 beam

>>> reg_a.order_vars.remove(beam_list=['gt1r'])

To remove specific variables in orbit_info

>>> reg_a.order_vars.remove(keyword_list=['orbit_info'],var_list=['sc_orient_time'])

To remove all variables and paths in ancillary_data

>>> reg_a.order_vars.remove(keyword_list=['ancillary_data'])

icepyx ChangeLog

This is the list of changes made to icepyx in between each release. Full details can be found in the commit logs.

Latest Release (Version 0.3.2)

What’s new in v0.3.2 (1 December 2020)

This is a summary of the changes in icepyx v0.3.2. See icepyx ChangeLog for a full changelog including other versions of icepyx. Note that during this time period we transitioned to master + development branches, with mandatory squash commits to the development branch from working branches in order to simplify the git history.

New Features

  • tracking tools set up

  • bibliography of icepyx uses

Bug fixes

  • resolve normal projection KeyError that resulted from a DAAC change to capabilities.xml

  • allow and validate numpy inputs for query objects

Deprecations

  • None

Maintenance

  • update Travis trigger to test PRs submitted from forks

Documentation

  • section on tracking and usage statistics

  • add current path to pip install -e instructions

Contributors

A total of 7 people contributed to this release. People with a “+” by their names contributed for the first time.

  • Amy Steiker

  • Anthony Arendt

  • Facundo Sapienza +

  • Jessica Scheick

  • Kelsey Bisson +

  • Tian Li +

  • alexdibella +

Version 0.3.1

What’s new in v0.3.1 (10 September 2020)

This is a summary of the changes in icepyx v0.3.0. See icepyx ChangeLog for a full changelog including other versions of icepyx. Note that during this time period we transitioned to master + development branches, with mandatory squash commits to the development branch from working branches in order to simplify the git history.

New Features

  • allow data querying using tracks and cycles

  • transition to use of query class object

  • add Black pre-commit hook and flake8 for code formatting and style consistency

  • created a development branch, enabling master to be the stable release branch

  • add icepyx release to PyPI, thereby enabling non-dev installs with pip

  • add code coverage badge for testing

  • enable alternative Earthdata authentication with netrc

  • automatically unzip downloaded files into a single directory

  • save order IDs and enable restart of download for previously ordered data

  • option to suppress order status emails from NSIDC

  • display variables in a dictionary format

  • overall, the variables class was overhauled: generalized, improved, and tested

Bug fixes

  • update bounding box assertions to allow crossing dateline

  • add try/except for gaierror

  • automatically order polygon vertices properly for submission to CMR and NSIDC APIs

  • fix index error due to NSIDC metadata changes

  • skip straight to variable subsetting without needing to manually run data search first

Deprecations

  • icesat2data class is deprecated. The existing functionality to search and obtain data has been migrated to the query class. A new class will be created for subsequent steps of working with data.

  • inclusive flag for variable.append and variable.remove methods has been removed

Maintenance

  • add PyPI building to Travis for new releases

  • update class architecture diagram and add to documentation page

  • refactor test suite into multiple modules

Documentation

  • update and improve installation instructions (especially for Windows users)

  • review and update all docstrings (including examples)

  • move examples to top level directory for easy finding (and make development notebooks harder to find)

  • create subsetting workflow example Jupyter noteobok

  • improve explanations in introductory example notebook

  • reorganized documentation structure to be more intuitive (and categorized)

Contributors

A total of 12 people contributed to this release. People with a “+” by their names contributed for the first time.

  • Amy Steiker +

  • Anna Valentine +

  • Bidhyananda Yadav +

  • Bruce Wallin +

  • David Shean +

  • Friedrich Knuth +

  • Jessica Scheick

  • Raphael Hagen

  • Tom Johnson +

  • Tyler Sutterley +

  • Wei Ji +

  • Zheng Liu

Version 0.2-alpha

What’s new in v0.2-alpha (6 May 2020)

These are the changes in pandas v0.2-alpha See icepyx ChangeLog for a full changelog including other versions of icepyx.

New Features

  • Ongoing work to refactor the icesat2data class into a more pythonic, modular structure

    • Create Earthdata login class object and call as an attribute of an icesat2data object

    • Move API (NSIDC and CMR) formatting functions to a separate module, APIformatting

    • Create ICESat-2 reference function module, is2ref

    • Create Granules class to get/order/download granules and call as an attribute of the icesat2data object

    • Create Variables class to interface with ICESat-2 nested variables

    • Create Parameters class for managing API inputs within APIformatting module

  • allow installation with pip and git

Bug fixes

  • Polygon handling will now put polygon coordinates into the correct order for submitting to CMR API

Deprecations

  • icesat2data class was refactored - access to some functionality changed

Maintenance

  • Update examples to work with refactored code

  • Update and expand tests for refactored code

Documentation

  • Generate and include a UML diagram

  • Update documentation to reflect refactored code

    • Separate into icesat2data API and component classes

Contributors

A total of 3 people contributed to this release. People with a “+” by their names contributed for the first time.

  • Jessica Scheick

  • Scott Henderson +

  • Zheng Liu

Version 0.1-alpha

What’s new in v0.1-alpha (7 April 2020)

This was the first official “release” of icepyx, after it had been in development since Fall 2019.

This changelog captures the general features of icepyx functionality at the time of this initial release, rather than providing a detailed account of all development steps and changes that were made.

Features

  • Functionality to query and order data from NSIDC using their built-in API and NASA’s CMR API

  • Visualization of input spatial parameters

  • Enable subsetting using NSIDC subsetter

  • Variable and variable path viewing and manipulation

  • Set up continuous integration testing with Travis

Bug fixes

  • No known bugs at release

Deprecations

  • is2class became icesat2data

Documentation

  • Example usage notebooks - using icepyx to access ICESat-2 data - subsetting using the NSIDC subsetter - comparing ATLAS altimeter and DEM data in Colombia

  • Generate documentation using Sphinx and automate building/updating to ReadtheDocs

Other

  • Develop attribution and contribution guidelines

  • Provide ICESat-2 Resources Guide

Contributors

A total of 6 people contributed to this release. People with a “+” by their names contributed for the first time.

  • Anthony Arendt +

  • Fernando Perez +

  • Jessica Scheick

  • Raphael Hagen +

  • Shashank Bhushan +

  • Zheng Liu +

Contribution Guidelines

Thank you for your interest in contributing to icepyx! We welcome and invite contributions of any size from anyone at any career stage and with any amount of coding experience. Since this is a community-based project, we’re thankful for your contributions to the utility and success of this project.

Here we provide a set of guidelines and information for contributing to icepyx. This project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms. Contributor Covenant

Ways to Contribute

  • Share your use cases and examples (as Jupyter Notebooks, scripts, etc.)

  • Submit bug reports and feature requests

  • Write code for everyone to use

  • Fix typos

  • Improve documentation and testing

The best way to report a problem, request a feature, find out if others are working on a similar problem or application, or let us know you’d like to contribute some code is to find the Issues tab and check if your problem/suggestion has already been reported. If so, please provide any additional information in the ongoing discussion. Otherwise, feel free to create a new issue and submit your problem or suggestions.

Requesting a Feature

Find the Issues tab at the top of GitHub repository and click New Issue button. Please give your suggestion a clear title and let us know if this is something you’d like to work on and contribute.

Reporting a Bug

Find the Issues tab at the top of GitHub repository and click New Issue button. Give your issue a clear title and describe the steps required to recreate it in as much detail as possible. If you can, include a small example that reproduces the error. More information and minimal examples will help us resolve issues faster.

Questions and Help

Please do not create issues to ask for help. A faster way to reach the community is through our Science/ICESat-2 subcategory on the Pangeo discourse page. We are excited to have you join an existing conversation or start a new post! Please note that a GitHub login is required to post on the discourse page.

Other Resources

Adding Examples

We are delighted you’d like to contribute your icepyx example! Examples may be in the form of executable scripts or interactive Jupyter Notebooks. Please make sure that each example has a descriptive name so someone not familiar with your project understands its general behavior. Fully working examples should be submitted using a pull request to the “development” branch, following the steps outlined below for Contributing Code.

Contributing Code

We follow a standard git workflow for code changes and additions. All submitted code, including our own, goes through the pull request process; no changes are pushed directly to the master or development branches. This allows our continuous integration (testing) process to ensure that the code is up to our standards and passes all of our tests (i.e. doesn’t break what’s already there and working). By having a development branch for daily work, we enable the master branch to remain stable between releases even as new features are being added.

First Steps

Before you begin writing code, please first check out our issues page. Someone may already be working on the same problem, and you may be able to contribute directly to their efforts. If not, create a new issue to describe what you plan to do.

General Guidelines

  • Make each pull request as small and simple as possible. Unrelated changes should be submitted as multiple pull requests.

  • Larger changes should be broken down into their basic components and integrated separately.

  • Bug fixes should be their own pull requests.

  • Do not commit changes to files irrelevant to your pull request, such as .gitignore

  • Write descriptive commit and pull request messages. Someone looking at the code a decade from now should know what you worked on from your commit message.

  • Be kind and encouraging to all contributors; be willing to accept constructive criticism to improve your code.

  • Review of pull requests takes time, particularly if the pull request is large and/or the commit messages are ambiguous.

Basic Steps to Contribute

We encourage users to follow the git pull request workflow. In a nutshell, the series of steps required to add new code is: (first time only)

  • Clone the repository

  • Fork the repo to your personal GitHub account

  • Add your fork as a remote

  • Add yourself to CONTRIBUTORS.rst (see Attribution for Contributions)

(each time you are going to make changes)

  • Update the development branch

  • Create a new branch

  • Make your changes and commit them to the branch

  • Push your changes to your fork

  • Make a pull request (on GitHub; pull requests will automatically be made against the development branch)

  • Push any additional, relevant changes to the same pull request (this will happen automatically if you push the changes to the same branch from which you made the pull request)

Licensing

icepyx is licensed under the BSD-3 license. Contributed code will also be licensed under BSD-3. If you did not write the code yourself, it is your responsibility to ensure that the existing license is compatible and included in the contributed files or you have documented permission from the original author to relicense the code.

Improving Documentation and Testing

Found a typo in the documentation or have a suggestion to make it clearer? Consider letting us know by creating an issue or (better yet!) submitting a fix. This is a great, low stakes way to practice the pull request process!

Discovered a currently untested case? Please share your test, either by creating an issue or submitting a pull request to add it to our suite of test cases.

Attribution for Contributions

We appreciate any and all contributions made to icepyx, direct or indirect, large or small. To learn more about how you will be recognized for your contributions, please see our Attribution Guidelines.

Attribution Guidelines

We are extremely grateful to everyone who has contributed to the success of the icepyx community, whether through direct contributions to or feedback about icepyx or as developers or maintainers of complimentary resources that are included within the icepyx ecosystem. This document outlines our goals to give appropriate attribution to all contributors to icepyx in ways that are fair and diverse and supportive of professional goals. To do so, we define broadly contributions as:

Efforts towards achieving icepyx’s goals, including writing code, tests, or documentation, development of example workflows, development, significant contributions, or maintenance of a tailored package that broadens the functionality of icepyx, feedback and suggestions, community building, etc.

We use the terms “contributors”, “developers”, and “authors” interchangeably. We will recognize contributions in the following ways.

Contributors List

Anyone who has contributed a pull request to icepyx is welcome to add themselves to the CONTRIBUTORS.rst file located in the top level directory; the file is packaged and distributed with icepyx. This process is optional, but is the easiest way for us to say “thank you” to everyone who has helped this project.

Example Workflows

Many of the example workflows included within icepyx were developed by individuals or small teams for educational or research purposes. We encourage example developers to provide proper recognition for these efforts both within the notebook itself and by adding contributors to the Contributors List for attribution as describered herein.

Version Release on Zenodo

When new releases of icepyx are archived on Zenodo, anyone who has contributed to icepyx will be invited to be an author. The list of potential authors will be generated using the Contributors List. Thus, if you have contributed to icepyx and would like to be included as an author, you must add your full name, affiliation (“Unaffiliated” is acceptable), and ORCID (optional) to CONTRIBUTORS.rst.

Author order will be determined based on co-author discussion during preparation of the version release, led by one or more of the members of the lead development team (Anthony Arendt, Lindsey Heagy, Fernando Perez, Jessica Scheick). Metrics for guiding the determination of author order will include the number of commits made to the repository (git shortlog -sne) and active engagement on GitHub (e.g. through issues and pull requests) and Discourse. Author order may also be modified on a case-by-case basis by consensus of the lead development team and top contributors.

If you do not wish to be included in the author list for Zenodo version releases, please add a note (e.g. “do not include in Zenodo”) to your entry.

Scientific Publications (Papers)

Authorship on scientific papers currently constitutes an important metric for assessing scientific merit and contribution and is often directly linked to career advancement. We aim to write academic papers for our software and its uses. Ideally, we will publish on an early version of the software and subsequently on major releases, use cases, or to advance the causes of open-source software and open science. To be eligible for authorship on scientific papers, contributors must:

  1. Contribute to the development (including code, documentation, and examples) of icepyx. Substantial non-code contributions constitute eligibility for authorship.

  2. Add themself to the Contributors List.

  3. Contribute ideas, participate in authorship discussions (see next paragraph), write, read, and review the manuscript in a timely manner, and provide feedback (acknowledgement of review is sufficient, but we’d prefer more).

Author order will be determined based on co-author discussion, led by the lead author, during the initial planning stages of manuscript preparation (i.e. as soon as an idea matures into a potential manuscript and before writing begins). Authorship will continue to be evaluated throughout the manuscript preparation process. Discussions will consider authorship norms (e.g. How does author order convey participation and prestige? How critical is first authorship to career advancement for each member of the team? Do an individual’s contributions meet authorship criteria or are they more suited to acknowledgements?). Author order determination will also consider metrics such as the number of commits since the last major release with an associated paper (git shortlog vX.0.0...HEAD -sne), contributions that do not have associated commits, and contributions to the preparation of the manuscript.

Disclaimer: These policies are not permanent or fixed and may change to accomodate community growth, best practices, and feedback.

Copyright notice: This document was inspired by the authorship guidelines provided by Fatiando a Terra and encourages potential co-authors to consider the resources provided by the NASA High Mountain Asia Team (HiMAT).

icepyx Development Plan

This page provides a high-level overview of where icepyx is headed. The list does not claim to be all inclusive, nor is it exclusive. Rather, we aim to provide a set of broad objectives to be met over the course of months to years, given that they require substantial developer time. These goals will evolve with time as development proceeds and new insights are gained (which could mean we ultimately opt NOT to implement some of them). If you would like to propose changes to this development plan, please see Modifying the Development Plan

Items with a smaller scope are tracked as issues on our GitHub issue tracker. We invite you to join the active discussions happening there.

Enhancing User Interactivity and Visualization

The process of querying, obtaining, and working with ICESat-2’s large datasets through a command line or similar interface poses challenges to many researchers who are uninterested in also becoming advanced software developers. However, downloading, storing, and backing up both raw and derived data are computationally and resource intensive, and frequent switching between tools for different steps in the research workflow are time intensive and difficult to reproduce. By simplifying the process of querying, subsetting, and visualizing data - both through relevant function methods and interactive tools like Jupyter widgets - icepyx aims to reduce or remove the need to download large, non-subsetted datasets, enable easy visualization throughout the data inquiry to analyzed data presentation steps, and provide a simple, community-based framework for reproducibility.

Improving Accessibility to Advanced Computing

Even as new resources and tools are developed to make computing easier, disciplinary researchers still face challenges finding time to maintain their computing environments while also meeting their research, teaching, and service objectives. Through integration of icepyx into the Pangeo ecosystem, only a handful of developers are able to manage the computational resources needed for working with ICESat-2 data, freeing researcher time and energy for exploring data. Further, the integration of Pangeo into existing advanced computing infrastructure (such as NASA’s ADAPT) will enable researchers to take advantage of cloud computing without a significant need for re-tooling.

Open Science Example Use Cases

We are currently partnering with multiple researchers conducting investigations using ICESat-2 datasets. Their research, from data collection and analysis to publication, will be used to drive the development of icepyx functionality, ultimately providing software contributions and example workflows. Current collaborations focus on:

  • impacts of blowing snow and low clouds on ICESat-2 measurements

  • snow height in non-glaciated regions

  • parameter assimilation into sea ice models

If you are or plan to work on a project using ICESat-2 datasets, we encourage you to use icepyx as a framework for finding and processing your data, from designing your analysis to writing code to analyze your data (if the analysis tools you need aren’t already a part of icepyx, that is!) to generating publication figures. Please contact us if you have any questions or would like some guidance to get involved!

Data Analysis and Interaction

Multiple forms of traditional and advanced computational analysis are used by researchers to probe and analyze large datasets to answer challenging questions about the systems the data describes. These analysis techniques include filtering, application of corrections, trend detection, feature detection, statistics, and machine learning, among others. icepyx aims to easily integrate existing libraries that specialize in these types of analysis by providing easy ways to manipulate ICESat-2 data into the appropriate form required by each library and showcasing the use of these complex analyses to answer glaciological questions through easily-modifiable example workflows based on actual use cases.

Validation and Integration with Other Products

The complexity of multiple data access systems, many with different metadata formats and API access types, presents a challenge for finding and integrating diverse datasets to construct long time series. Many open-source resources provide tools for manipulating certain types of datasets, but few collate these resources into one computing environment (see Improving Accessibility to Advanced Computing) and provide wrappers and examples to easily conduct frequently performed analysis tasks. This portion of the development plan, driven by researcher use cases, will combine existing resources with new ones to improve researcher ability to easily compare diverse datasets across varying sensor types and spatial and temporal scales.

Modifying the Development Plan

Everyone is invited to review and propose new items for the Development Plan. icepyx is continually evolving and its direction is driven by your feedback and contributions.

Items listed in the Development Plan should be brief summaries of more detailed proposals. Each item listed should include:

  1. Summary of proposed changes/additions

  2. Motivation for the changes

  3. Statement describing how the changes fit within the icepyx scope

  4. More detailed plan for changes (e.g. implementation plan, examples (even if not implemented), potential issues)

Please submit your proposal as a GitHub issue, which will provide the developers and community members an opportunity to provide feedback on your suggestion. Once there is agreement on the proposal, submit a pull request to update the Development Plan, including a link to the discussion issue.

# Contributor Covenant Code of Conduct

## Our Pledge

We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.

We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.

## Our Standards

Examples of behavior that contributes to a positive environment for our community include:

  • Demonstrating empathy and kindness toward other people

  • Being respectful of differing opinions, viewpoints, and experiences

  • Giving and gracefully accepting constructive feedback

  • Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience

  • Focusing on what is best not just for us as individuals, but for the overall community

Examples of unacceptable behavior include:

  • The use of sexualized language or imagery, and sexual attention or advances of any kind

  • Trolling, insulting or derogatory comments, and personal or political attacks

  • Public or private harassment

  • Publishing others’ private information, such as a physical or email address, without their explicit permission

  • Other conduct which could reasonably be considered inappropriate in a professional setting

## Enforcement Responsibilities

Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.

Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.

## Scope

This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at jbscheick-at-gmail-dot-com. All complaints will be reviewed and investigated promptly and fairly.

All community leaders are obligated to respect the privacy and security of the reporter of any incident.

## Enforcement Guidelines

Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:

### 1. Correction

Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.

Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.

### 2. Warning

Community Impact: A violation through a single incident or series of actions.

Consequence: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.

### 3. Temporary Ban

Community Impact: A serious violation of community standards, including sustained inappropriate behavior.

Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.

### 4. Permanent Ban

Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.

Consequence: A permanent ban from any sort of public interaction within the project community.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

Community Impact Guidelines were inspired by [Mozilla’s code of conduct enforcement ladder](https://github.com/mozilla/diversity).

[homepage]: https://www.contributor-covenant.org

For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.

ICESat-2 Open-Source Resources Guide

This guide contains information regarding available resources for working with ICESat-2 datasets, both specifically (e.g. for ICESat-2 data) and more broadly (e.g. point cloud analysis of LiDAR datasets). It includes resources formally developed by/with support from NASA as well as individual and community efforts stemming from personal interest to ongoing research workflows.

Please feel free to add your project or another resource to this guide by submitting a pull request. We reserve the right to reject suggested resources that fall outside the scope of icepyx.

Resources Used in the Initial Development of icepyx

First ICESat-2 Cryospheric Hackweek at the University of Washington (June 2019)

This June 2019 event resulted in the production of a series of tutorials, developed primarily by members of the ICESat-2 Science Team and early data users, aimed at educating the cryospheric community in obtaining and using ICESat-2 datasets. During the actual Hackweek, teams of researchers and data scientists developed a series of interesting projects related to their interests/research.

The available tutorials, most of which contain one or more Jupyter Notebooks to illustrate concepts, are listed below. Additional information for citing (including licensing) and running (e.g. through a Pangeo Binder) these tutorials can be found at the above link.

  1. Overview of the ICESat-2 mission (slides)

  2. Introduction to Open Science and Reproducible Research

  3. Access and Customize ICESat-2 Data via NSIDC API

  4. Intro to HDF5 and Reduction of ICESat-2 Data Files

  5. Clouds and ICESat-2 Data Filtering

  6. Gridding and Filtering of ICESat/ICESat-2 Elevation Change Data

  7. ICESat-2 for Sea Ice

  8. Geospatial Data Exploration, Analysis, and Visualization

  9. Correcting ICESat-2 data and related applications

  10. Numerical Modeling

Though in many cases preliminary, these project repositories can provide useful starting points to develop effective cryospheric workflows where more formal examples and functionality have not yet been developed.

Sea Ice

  • Floes are Swell

    • Calculate chord length (CLD) and lead width (LWD)

  • Segtrax

    • Create trajectories of sea ice motion (creates Python trajectory class)

Glaciers and Ice Sheets

  • Crackup

    • Investigating small-scale features such as crevasses and water depth

  • GlacierSat2

    • Constrain surface types (e.g. wet vs. dry snow) using ICESat-2 data over the Juneau Icefield, working towards looking at seasonal elevation changes

  • WaterNoice

    • Detection of hydrologic features (e.g. meltwater ponds, firn aquifer seeps, blue ice megadunes, icebergs, etc.) in ATL06 land ice product

  • SnowBlower/blowing snow

    • Evaluate the blowing snow flag and look at blowing snow models

  • Cross-trak (xtrak)

    • Interpolation between ICESat-2 tracks

    • Create gridded elevation data from multiple ICESat-2 tracks

  • Ground2Float

    • Identify grounding zones using ICESat-2 data (using the slope-break method)

  • Topohack

    • Resolve topography over complex terrain

Complementary GitHub Repositories

Here we describe a selection of publicly available Python code posted on GitHub with applicability for working with ICESat-2 data. This includes repositories that are more broadly designed for working with LiDAR/point cloud datasets in general. These repositories represent independent but complimentary projects that we hope to make easily interoperable within icepyx in order to maximize capabilities and minimize duplication of efforts. Conversations about how to best accomplish this have been ongoing since the conception of icepyx, and we welcome everyone to join the conversation (please see our contact page).

Note: This list is a compilation of publicly available GitHub repositories and includes some annotations to reflect how they relate to icepyx. Please check each repository’s licensing information before using or modifying their code. Additional resources having to do specifically with obtaining ICESat-2 data are noted in the last section of this document.

  • captoolkit

    • by Fernando Paolo, Johan Nilsson, Alex Gardner

    • NASA’s JPL Cryosphere Altimetry Processing Toolkit

    • Set of command line utilities to process, reduce, change format, etc. altimetry data from ICESat-2 and several other altimeters (e.g. ERS, CryoSat-2, IceBridge)

    • Includes utilities to read and extract variables of interest, compute and apply various corrections (e.g. tides, inverse barometer), detrend and correct data, do a variety of geographic computations and manipulations (e.g. raster math, masking, slope/aspect), and tile/grid/reduce data

    • We envision making captoolkit’s utilities available as part of the icepyx ecosystem in order for users to quickly obtain and pre-process/correct/process ICESat-2 data.

  • Icesat2-viz

    • by Aimee Barciauskas-bgse

    • Exploration for visualizing ICESat-2 data products; focused on 3-D visualization using mapbox tools

    • We hope to take advantage of Icesat2-viz’s work to provide 3-D visualizations of ICESat-2 data to expand on the 2-D visualization options currently available within icepyx.

  • Nsidc-subsetter

    • by Tyler Sutterly

    • Retrieve IceBridge, ICESat, and ICESat-2 data using the NSIDC subsetter API

    • Command line tool

    • Download data and convert it into a georeferenced format (e.g. geojson, kml, or shapefile)

    • We envision use of Nsidc-subsetter to improve interoperability between icepyx and the NSIDC subsetter API. Currently, icepyx has very limited subsetting capabilities that are not easy to access or find more information about.

  • pointCollection

    • by Ben Smith

    • Efficiently organize and manipulate a database of points using this set of utilities

    • Access data fields using dot syntax and quickly index subsets of previously downloaded data

    • We hope to capitalize on some of the concepts of data access, indexing, and processing presented in pointCollection to improve our interfacing with ICESat-2 data within icepyx.

Other Ways to Access ICESat-2 Data

icepyx aims to provide intuitive, object-based methods for finding, obtaining, visualizing, and analyzing ICESat-2 data as part of an open, reproducible workflow that leverages existing tools wherever possible (see Complementary GitHub Repositories) and can be run locally, using high performance computing, or in the cloud using Pangeo. A few other options available for querying, visualizing, and downloading ICESat-2 data files are:

  • NSIDC (DAAC) Data Access

    • Select “ICESat-2 Data Sets” from the left hand menu. Choose your dataset (ATL##). Then, use the spatial and temporal filters to narrow your list of granules available for download.

  • OpenAltimetry

    • Collaboration between NSIDC, Scripps, and San Diego Supercomputer Center

    • Enables data browsing on a map and selection of tracks and interactive data exploration for the higher level ICESat-2 datasets (i.e. ATL06+)

Ongoing Efforts

In addition to the ongoing development of icepyx itself, the ICESat-2 Cryosphere community continues to grow through a number of workshops and events.

Second [Virtual] ICESat-2 Cryospheric Hackweek Facilitated by the University of Washington

COVID-19 forced the in-person event to be cancelled, but we’re excited to extend the Hackweek model into a virtual space, ultimately making it more accessible by removing the need to travel. This year’s event is scheduled to take place from 15-18 June 2020, with multiple instructional sessions taking place during the preceding week (8-12 June) to limit the daily duration and accomodate multiple time zones. Though only selected participants are able to tune in to the live tutorial sessions, the materials being taught are freely available in the ICESat-2 Hackweek GitHub Organization respositories. Watch here for updates on projects conducted during the hackweek, and feel free to check out the event’s website.

Contact Us

The best way to contact us depends on what information you’re looking for.

  • Need help installing, running, or using icepyx? Add a new topic to ask for help on Discourse (after reviewing the documentation and existing topics, of course, to see if they answer your question!) or attend one of our regular virtual meetings (details below).

  • Found a bug or have a feature request? Post an issue on GitHub!

  • Have an idea you’d like to discuss? Start a conversation on Discourse or attend one of our regular virtual meetings (details below).

  • Want to get involved? Do one or more of the above, or reach out to one of the dev team members individually. We’re excited to hear your thoughts and provide help!

Regular Meeting Schedule

Our team (developers, users, scientists, educators) meets regularly via Zoom to provide support, troubleshoot issues, and plan development. We meet on:

  • the second Tuesday of the month at 4pm GMT (12pm Eastern, 9am Pacific)

  • the fourth Monday of the month at 8pm GMT (4pm Eastern, 1pm Pacific)

Additional information about logging in to the meetings can be found on this Discourse post.

Absolutely NO previous software development experience is necessary to attend any meeting. Think of them more like coffee hour mixed with office hours than a conference call. We look forward to seeing you there!

Tracking icepyx Usage

How is icepyx being used by the ICESat-2 data user community?

Is your team or project using icepyx but not listed below? Please add your organization to the appropriate list with a link to your project/product (or get in touch and we’ll add it)!

Publications and Presentations

ICESat-2 peer-reviewed research that utilizes icepyx and presentations that feature or explain icepyx

1

Arendt, Anthony, Scheick, Jessica, Shean, David, Buckley, Ellen, Grigsby, Shane, Haley, Charley, Heagy, Lindsey, Mohajerani, Yara, Neumann, Tom, Nilsson, Johan, Markus, Thorsten, Paolo, Fernando S., Perez, Fernando, Petty, Alek, Schweiger, Axel, Smith, Benjamin, Steiker, Amy, Alvis, Sebastian, Henderson, Scott, Holschuh, Nick, Liu, Zheng, and Sutterly, Tyler. 2020 ICESat-2 Hackweek Tutorials. August 2020. URL: https://doi.org/10.5281/zenodo.3966463, doi:10.5281/zenodo.3966463.

2

Li, T., Dawson, G. J., Chuter, S. J., and Bamber, J. L. Mapping the grounding zone of larsen c ice shelf, antarctica, from icesat-2 laser altimetry. The Cryosphere, 14(11):3629–3643, 2020. URL: https://tc.copernicus.org/articles/14/3629/2020/, doi:10.5194/tc-14-3629-2020.

3

Scheick, J, Arendt, A, Heagy, L, and Perez, F. Introducing icepyx, an open source Python library for obtaining and working with ICESat-2 data. 2019. Abstract and poster. American Geophysical Union Fall Meeting, San Francisco, California, USA. 9-13 December 2019. doi:10.1002/essoar.10501423.1.

Downloads

Estimating usage of open-source software is a fundamentally difficult task, and “easy” metrics like number of downloads have the potential to be misleading.

We are excited by the enthusiastic adoption of icepyx by the ICESat-2 data user community, and despite these limitations in data tracking metrics, we have begun (November 2020) to track user downloads and page views as shown below.

GitHub Traffic

Clones and views of the icepyx library directly on GitHub.

Plots showing GitHub traffic (icepyx repository clones and views).

PyPI Downloads

Non-mirrored downloads of icepyx from the Python Package Index (e.g. using pip install icepyx).

Figure showing the number of downloads of the icepyx library from the Python Package Index by non-mirroring sites since the package became available through that index.