From 44655439f498efa5733355d142dc9ec6851b3073 Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Mon, 7 Oct 2024 15:17:32 -0600 Subject: [PATCH 1/9] fix: edits to pep 8 page --- clean-modular-code/python-pep-8.md | 108 ++++++++++++++++------------- 1 file changed, 61 insertions(+), 47 deletions(-) diff --git a/clean-modular-code/python-pep-8.md b/clean-modular-code/python-pep-8.md index e5a8a68..f9e6504 100644 --- a/clean-modular-code/python-pep-8.md +++ b/clean-modular-code/python-pep-8.md @@ -16,10 +16,10 @@ kernelspec: # Use PEP 8 To Write Easier-to-Read Code -:::{admonition} Learning Objectives +:::{admonition} What you will learn :class: tip -* Describe the benefits of using code standards. +* Describe the benefits of using code styles guides. * Explain the PEP 8 style guide and how it helps promote code readability. * Describe key components of the PEP 8 style guide, including naming conventions and white space. * List tools to help you apply the PEP 8 style guide to your code. @@ -28,13 +28,13 @@ kernelspec: ## What is Python PEP 8 code style? -Code syntax standards refer to rules associated with how code is formatted. These rules can including things like: +Code syntax standards refer to rules associated with how code is formatted. These rules include things like: * How to space code elements in a script, * How to format and create comments, and -* Naming conventions for variables, functions and classes +* Naming conventions for variables, functions, and classes -## Why Use Code Standards When Writing Python Code +## Why use code standards when writing Python code Code standards help make your code more readable. Consider this page that you are reading right now. Some conventions are followed that most of us are familiar with (but may not even think about). These conventions include: @@ -47,33 +47,35 @@ These conventions lead to text that you can read easily, like this: `This is a sentence. And another sentence with a Name and a location like Florida, USA.` -Now imagine reading a book that has no spacing, no capitalization and didn't follow the regular English language writing conventions that you know. This book would become increasingly hard to read. For example have a look at the example below: +Now imagine reading a book with no spacing, no capitalization and that doesn't follow the regular English language writing conventions. This book would be difficult to read. Take the example below: `this is a sentence.and another sentence with a name.this text could go on forever. whatwouldhappenifweneverusedspaces?` -Code standards, just like any other language standard, are designed to make code easier to understand. +Code style standards, just like any other language standard, are designed to make code easier to read and understand. Below, you will learn about the PEP 8 standard for the **Python** scientific programming language. This is the standard used by many **Python** users. -## About the PEP 8 Standard for Python +## About the PEP 8 standard for Python PEP 8 is the style guide that is widely used in the **Python** community. This guide includes rules about naming objects, spacing rules and even how the code is laid out. -**Python** is developed and maintained by an open source community, and thus, it is not really possible to enforce the standard in mandatory way. Rather, community members choose to adhere to PEP 8 recommendations whenever possible, so that they can contribute code that can easily be read and used by the greater community of users. +**Python** is developed and maintained by an open source community, and thus, it is not possible to make code standards mandatory. Rather, community members choose to adopt PEP 8 recommendations whenever possible to contribute code that can easily be read and used by the greater community of users. -PEP 8 covers many aspects of code readability including: +PEP 8 covers many aspects of code readability, including: * naming conventions * use of comments * line lengths * use of white space -## PEP 8 Naming Conventions +## PEP 8 naming conventions The text in this section is summarized from the PEP 8 Style Guide published by the Python Software Foundation. -### Naming Convention Terminology Review +:::{tip} + +**Terminology Teview** First, let's review some terminology associated with naming conventions. @@ -97,25 +99,27 @@ First, let's review some terminology associated with naming conventions. * **Capitalized_Words_With_Underscores:** This approach is not recommended. Use one convention and stick with it. -### Name Variables Using snake_case And All Lower Case +::: -In general, it is recommended that you keep naming conventions standard in your code. We suggest a convention that uses **snake_case** and all lowercase letters in your code for variable and function names. +### Use snake_case and all lower case for variable names -``` +It is recommended that you use standard naming conventions in your code. We suggest that you use **snake_case** and all lowercase letters in your code for variable and function names. Like this: + +```python variable_one variable_two ``` -### Name Classes Using CamelCase or CapsCase +### Use CamelCase or CapsCase for class names -While regular variables and functions should use snake_case, PEP 8 +While regular variables and functions should use **snake_case**, PEP 8 suggests that you use `CamelCase` for class definitions. -``` +```python class PlotBasicObject(object): ``` -### Avoid Using Single Character Letters That Could Be Confused with Numbers +### Avoid using single character letters that could be confused with numbers Avoid using the characters: @@ -123,34 +127,34 @@ Avoid using the characters: * 'O' (uppercase letter oh), or * 'I' (uppercase letter eye) -as single character variable names. +as single-character variable names. These characters can be difficult to distinguish from numbers when using certain font families. -For example, the letter `l` can sometimes look a lot like the number `1`. If you need to use the letter `l` as a variable (this is not suggested!), considering user an uppercase letter instead. +For example, the letter `l` looks similar to the number `1`. -## Python PEP 8 Documentation Standards for Comments +## Comments and PEP 8 Documentation is an important part of writing great code. Below are some of the important PEP 8 conventions associated with documentation. -### 1. Python Comments Should Have a Space After the `#` Sign with the First Word Capitalized +### 1. Python comments should have a space after the `#` sign with the first word capitalized -Following the PEP8 style guide, single line comments should +Following the PEP8 style guide, single-line comments should start with the `#` sign followed by a space. The first word of the comment should be capitalized. Like this: `# This is a PEP 8 conforming comment` -The comment below does NOT conform to PEP8 standards +The comment below does NOT conform to PEP 8 standards `#this comment does not conform to PEP 8 standards` -### 2. Multi-line comments Used in Functions (docstrings) Should Have a Short Single Line Description Followed By More Text +### 2. Multi-line function comments (docstrings) Multi-line comments are most commonly used when creating docstrings. A docstring is the text that follows a function definition. This text helps you or someone using a function understand what the function does. -Following the PEP8 style guide, you create a function docstring using three quotes `"""`. The first line or text following the quotes should be a short, concise description of what the function does. +Following the PEP8 style guide, you create a function docstring using three quotes `"""`. The first line of text following the quotes should be a short, concise description of what the function does. Below that, you can add as much text as you'd like that provides more detail about what the function does. @@ -171,20 +175,20 @@ return the_total_sum ## Line Length -PEP 8 guidelines suggest that each line of code (as well as comment lines) should be 79 characters wide or less. This is a common standard used in other languages, including **R**. +PEP 8 guidelines suggest that both code and comment lines should all be 79 characters wide (or less). This standard is common in other languages, such as **R**. :::{tip} Most text editors allow you to set up guides to see how long your code is. You can then use these guides to create line breaks in your code. ::: -## Python PEP 8 Rules for White Space +## Python PEP 8 rules for white space Some of the white space rules have already been discussed above. These including adding a single space after a comment `# Comment here`. There are also rules associated with spacing throughout your code. These include: -* **Add blank line before a single line comment (unless it is the first line of a cell in Jupyter Notebook)** Blank lines help to visually break up code. Consider reading this page, if all of the text was mashed together in one long paragraph, it would be more difficult to read. However, when you break the text up into related paragraphs, it becomes a lot easier to read. +* **Add a blank line before a single-line comment (unless it is the first line of a cell in Jupyter Notebook)** Blank lines help to break up code visually . Consider reading this page: If all of the text was mashed together in one long paragraph, it would be more difficult to read. However, when you break the text up into related paragraphs, it becomes a lot easier to read. ```python @@ -194,8 +198,8 @@ b = 3+4 c = a+b # Read in and plot some -precip_timeseries = pd.readcsv("precip-2019.csv") -precip_timeseries.plot() +review_timeseries = pd.readcsv("pyos-data.csv") +review_timeseries.plot() ``` The code below is more difficult to read as the spacing does not break up the text. @@ -205,7 +209,7 @@ The code below is more difficult to read as the spacing does not break up the te a=1+2 b=3+4 c=a+b -data=pd.readcsv("precip-2019.csv") +data=pd.readcsv("pyos-data.csv") data.plot() ``` @@ -214,7 +218,7 @@ code becomes even more important when you start working in Jupyter Notebooks whi ```python # Process some data here -data=pd.readcsv("precip-2019.csv") +data=pd.readcsv("pyos-data.csv") # Plot data - notice how separating code into sections makes it easier to read fig, ax = plot.subplots() @@ -224,27 +228,37 @@ plt.show() ## Summary -- PEP 8 and Python -The text above provides a broad overview of some of the PEP 8 guidelines and conventions for writing **Python** code. It is not fully inclusive all of all the standards which are included in the full, online PEP 8 documentation. +The text above provides a broad overview of some of the PEP 8 guidelines and conventions for writing **Python** code. -## Tools For Applying PEP 8 Formatting To Your Code +:::{important} +This page is not fully inclusive of all of the PEP 8 standards. +::: -There are many different tools that can help you write code that is PEP 8 compliant. A tool that checks the format of your code is called a linter. -Some linters will reformat your code for you to match the standards. These include tools like Black. Or the autopep8 tool for Jupyter Notebook. ++++ -Other linters will simply check your code and tell you if things need to be fixed. A few **Python** packages that perform linting are listed below. +## Tools for applying PEP 8 format to your code -* pep8, a `Python` package that can help you check your code for adherence to the PEP 8 style guide. -* autopep8, another `Python` package that can be used to modify files to the PEP 8 style guide. +Many different tools can help you write code that is PEP 8 compliant. A tool that checks the format of your code is called a linter. -`Python` community members expect that your code will adhere to the PEP 8 standard, and if it does not, they generally will not be shy to tell you that your code is not "Pythonic"! +Some linters will reformat your code so that it matches the standards. -+++ {"editable": true, "slideshow": {"slide_type": ""}} +* [Black](https://black.readthedocs.io/en/stable/) has been a popular tool in the scientific Python ecosystem for several years. +* More recently, many people are moving to [ruff which now provides Jupyter support.](https://docs.astral.sh/ruff/configuration/#jupyter-notebook-discovery). Ruff is a perfect tool for you to use if you are developing your code in `.py` files. + + +:::{note} +Ruff doesn't currently work well with Jupyter / JupyText and myst markdown notebooks. But it can be easily configured into a .precommit workflow, which is used alongside Git and GitHub and will be applied every time you make a commit to a GitHub repo. +:::: -## Additional Resources +The pyOpenSci community has been slowly adopting Ruff because it can run many code formatters with a single configuration file, making it a convenient and easy-to-use tool. -* The PEP 8 Style Guide +:::{admonition} Linter vs. code formatter +:class: tip + +A code formatter is a tool that helps you modify your code to follow code standards. A linter checks your code and tells you if things need to be fixed, but it generally won't fix them for you. -* How To Write Beautiful Python Code with PEP 8 +Ruff is both a linter and code formatter which is why we like to use it when developing both software and .py file based workflows. +::: -* The Hitchhiker's Guide to Python by Tanya Schlusser and Kenneth Reitz ++++ {"editable": true, "slideshow": {"slide_type": ""}} From 130393e93bc65f73f46e4f68096bfebc50847bd2 Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Mon, 7 Oct 2024 15:26:41 -0600 Subject: [PATCH 2/9] feat: pep 8 page --- clean-modular-code/pep8-package-imports.md | 79 ---------------------- clean-modular-code/python-pep-8.md | 66 ++++++++++++++++++ 2 files changed, 66 insertions(+), 79 deletions(-) delete mode 100644 clean-modular-code/pep8-package-imports.md diff --git a/clean-modular-code/pep8-package-imports.md b/clean-modular-code/pep8-package-imports.md deleted file mode 100644 index 5807ba7..0000000 --- a/clean-modular-code/pep8-package-imports.md +++ /dev/null @@ -1,79 +0,0 @@ ---- -jupytext: - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.16.4 -kernelspec: - display_name: Python 3 (ipykernel) - language: python - name: python3 ---- - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -# Best Practices for Importing Python Packages In Scientific Code - -There are a set of best practices that you should follow when importing **Python** packages in your code. These best practices are outlined in the PEP 8 guidelines and apply to both **Python** scripts and to working in **Jupyter Notebook** files. - -## Import Python Libraries at the Top of Your Script or Notebook - -It is good practice to import all of the packages that you will need at the top of your **Python** script (.py file) or in the first code cell of a **Jupyter Notebook** file. - -This allows anyone looking at your code to immediately know what packages they need to have installed in order to successfully run the code. This rule also follows the PEP 8 conventions for **Python** code. - -```python -import os - -import pandas as pd -import numpy as np -``` - -Once you have imported all of the packages that you need to run your code in a script, you have access to all of the functions and classes defined in each package. - -If these imports are at the top of the script or **Jupyter Notebook** file, then you will be able to use those packages in any code lines that follow. - -This means that if you import a package *after* running some code that requires that package, your code will not run successfully. - - -## 2. List Package Imports Following PEP 8 Standards: Most Common First, Followed By Third Party - -PEP 8 also specifies the order in which you should list your imports as follows (starting with the most commonly used): - -> Imports should be grouped in the following order: -> Standard library imports. -> Related third party imports. -> Local application/library specific imports. -> You should put a blank line between each group of imports. - -You may be wondering, what is a standard library import? The standard library imports are commonly used tools that are general in purpose and are part of the standard library of **Python**. These including things like: - -* **os**: handle files and directories. -* **glob**: create lists of files and directories for batch processing. - -In the PEP 8 order, other commonly used packages that are general in purpose will follow such as: - -* **numpy**: work with data in array formats. -* **matplotlib**: plot data. -* * **Pandas**: to work with tabular data. - -A PEP 8 order of imports for commonly used **Python** packages for science would look something like this: - -```python -import os -import glob - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -``` - -Note that there is a space between the standard imports (`glob` and `os`) -and the rest of the third-party imports. - -## What are Local application/library specific imports - -Local application / library specific imports refer to tool that you have created locally or just for your own work. - -TODO: more here... diff --git a/clean-modular-code/python-pep-8.md b/clean-modular-code/python-pep-8.md index f9e6504..5d070e3 100644 --- a/clean-modular-code/python-pep-8.md +++ b/clean-modular-code/python-pep-8.md @@ -262,3 +262,69 @@ Ruff is both a linter and code formatter which is why we like to use it when dev ::: +++ {"editable": true, "slideshow": {"slide_type": ""}} + +DRAFT!! + + +## Best Practices for Importing Python Packages In Scientific Code + +There are a set of best practices that you should follow when importing **Python** packages in your code. These best practices are outlined in the PEP 8 guidelines and apply to both **Python** scripts and to working in **Jupyter Notebook** files. + +## Import Python Libraries at the Top of Your Script or Notebook + +It is good practice to import all of the packages that you will need at the top of your **Python** script (.py file) or in the first code cell of a **Jupyter Notebook** file. + +This allows anyone looking at your code to immediately know what packages they need to have installed in order to successfully run the code. This rule also follows the PEP 8 conventions for **Python** code. + +```python +import os + +import pandas as pd +import numpy as np +``` + +Once you have imported all of the packages that you need to run your code in a script, you have access to all of the functions and classes defined in each package. + +If these imports are at the top of the script or **Jupyter Notebook** file, then you will be able to use those packages in any code lines that follow. + +This means that if you import a package *after* running some code that requires that package, your code will not run successfully. + + +## 2. List Package Imports Following PEP 8 Standards: Most Common First, Followed By Third Party + +PEP 8 also specifies the order in which you should list your imports as follows (starting with the most commonly used): + +> Imports should be grouped in the following order: +> Standard library imports. +> Related third party imports. +> Local application/library specific imports. +> You should put a blank line between each group of imports. + +You may be wondering, what is a standard library import? The standard library imports are commonly used tools that are general in purpose and are part of the standard library of **Python**. These including things like: + +* **os**: handle files and directories. +* **glob**: create lists of files and directories for batch processing. + +In the PEP 8 order, other commonly used packages that are general in purpose will follow such as: + +* **numpy**: work with data in array formats. +* **matplotlib**: plot data. +* * **Pandas**: to work with tabular data. + +A PEP 8 order of imports for commonly used **Python** packages for science would look something like this: + +```python +import os +import glob + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +``` + +Note that there is a space between the standard imports (`glob` and `os`) +and the rest of the third-party imports. + +## What are Local application/library specific imports + +Local application / library specific imports refer to tool that you have created locally or just for your own work. From e54ac8b5c57bd107e9d185e8c7d0db7dacb52bed Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Mon, 7 Oct 2024 15:48:24 -0600 Subject: [PATCH 3/9] feat: fix toctree --- clean-modular-code/intro-clean-code.md | 34 ++++++++++---------------- 1 file changed, 13 insertions(+), 21 deletions(-) diff --git a/clean-modular-code/intro-clean-code.md b/clean-modular-code/intro-clean-code.md index f806026..7fd4f0e 100644 --- a/clean-modular-code/intro-clean-code.md +++ b/clean-modular-code/intro-clean-code.md @@ -20,6 +20,8 @@ jupyter: --- +# Write Clean, Modular, DRY Code + :::{toctree} :hidden: :caption: Lessons @@ -27,7 +29,6 @@ jupyter: Intro Python Code Style -Package imports Don't Repeat Yourself Functions Function checks @@ -44,8 +45,6 @@ Conditional statements Tests & Checks ::: - - :::{toctree} :hidden: :caption: Activities @@ -56,10 +55,6 @@ Clean Code: Activity 2 Clean Code: Activity 3 ::: - - -# Write Clean, Modular, DRY Code - :::{note} After completing this lesson, you will be able to: @@ -78,9 +73,9 @@ Pythonic code also takes full advantage of Python's features which include: to write more elegant and efficient code. -## Characteristics of Pythonic code: +## Characteristics of Pythonic code -### **It's Readable**: +### **It's Readable** Pythonic code is easy to read and understand, often adhering to the **Zen of Python** (a set of guiding principles for Python’s design). @@ -109,7 +104,7 @@ todays_date Compare the variable `foovar` to `todays_date`. Which variable name tells you more about the information that it contains? -### **It's Concise** +### **It's Concise** Pythonic code is concise but not at the expense of clarity. An example of concise code is to use features like list comprehensions and built-in functions. @@ -146,11 +141,11 @@ for i, language in enumerate(languages): ``` -### Clean code is DRY & avoids repitition +### Clean code is DRY & avoids repitition Pythonic code avoids repetition. DRY (Don't Repeat Yourself) code is written in a way that both avoids repetition and is well organized. This makes it easier to maintain and extend. -### Pythonic code is expressive +### Pythonic code is expressive Pythonic code communicates the programmer's intent clearly, making it easier for others to understand the purpose of the code at a glance. @@ -165,7 +160,7 @@ def fahr_to_kelvin(fahr): return ((fahr - 32) * (5 / 9)) + 273.15 ``` -### Pythonic code is well-documented +### Pythonic code is well-documented Docstrings are Pythonic because they prioritize code readability and clarity, providing clear descriptions of a function’s purpose, parameters, and return values. By embedding documentation directly in the code, docstrings make it easy for developers to understand and use functions or classes without needing to read the implementation details. @@ -196,12 +191,13 @@ def fahr_to_kelvin(fahr): -## Tools to help you write better, more Pythonic code - code formatters, linters and LLM's +## Tools to help you write better, more Pythonic code - code formatters, linters and LLM's While the above tasks used to require manual code editing, in today's world, you can use a suite of automated tools such as linters and code formatters, combined with LLM's to help you write better, cleaner and more Pythonic code for scientific workflows. -### LLMS -LLMs (Large Language Models) can be useful for... +### LLMS + +LLMs (Large Language Models) can be useful for... however, it's important that you are careful about how you use them because @@ -211,12 +207,9 @@ however, it's important that you are careful about how you use them because * etc. however with correct promots, and if you build your eye for identifying problems, and combined with tools that will help you with your code, as you write it, they can be effective tools in your workfhlow dev process. - - - In the next lessons, you will learn more about making tools and approaches to making your code more Pythonic -You will then learn about tools that you can use to format your code and identify problem points including: +You will then learn about tools that you can use to format your code and identify problem points including: * LLM's like GitHub co-pilot * ChatGPT @@ -227,5 +220,4 @@ Code formatters like: * black * ruff - From 43c029c1d0a589fb93123efa96232388cd1b6366 Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Tue, 8 Oct 2024 14:18:09 -0600 Subject: [PATCH 4/9] feat(fix): pep 8 lesson --- clean-modular-code/python-pep-8.md | 398 +++++++++++++---------------- 1 file changed, 180 insertions(+), 218 deletions(-) diff --git a/clean-modular-code/python-pep-8.md b/clean-modular-code/python-pep-8.md index 5d070e3..6f81e62 100644 --- a/clean-modular-code/python-pep-8.md +++ b/clean-modular-code/python-pep-8.md @@ -14,206 +14,213 @@ kernelspec: +++ {"editable": true, "slideshow": {"slide_type": ""}} -# Use PEP 8 To Write Easier-to-Read Code +# Python code style for readability and usability :::{admonition} What you will learn :class: tip -* Describe the benefits of using code styles guides. -* Explain the PEP 8 style guide and how it helps promote code readability. -* Describe key components of the PEP 8 style guide, including naming conventions and white space. -* List tools to help you apply the PEP 8 style guide to your code. +* How to follow the PEP 8 style guide to write Python code that’s easy to read and understand. +* Best practices for naming variables, using comments, and formatting code. +* Tools to help you apply PEP 8 to your code automatically. ::: -## What is Python PEP 8 code style? +## Why code style and Python PEP 8 matters -Code syntax standards refer to rules associated with how code is formatted. These rules include things like: +Just like good grammar makes text easier to read, PEP 8 helps make your code easier to understand. It enforces rules on naming variables, capitalization, formatting code, and structuring your script. Well-formatted code also makes it easier for you to share code, given it will be easier for others to understand. -* How to space code elements in a script, -* How to format and create comments, and -* Naming conventions for variables, functions, and classes - -## Why use code standards when writing Python code - -Code standards help make your code more readable. Consider this page that you are reading right now. Some conventions are followed that most of us are familiar with (but may not even think about). These conventions include: - -* Capitalize the first letter of a sentence. -* Capitalize the first letter of someone's name. -* Add a space after the end of a sentence. -* Add a space after each word. - -These conventions lead to text that you can read easily, like this: - -`This is a sentence. And another sentence with a Name and a location like Florida, USA.` - -Now imagine reading a book with no spacing, no capitalization and that doesn't follow the regular English language writing conventions. This book would be difficult to read. Take the example below: - -`this is a sentence.and another sentence with a name.this -text could go on forever. whatwouldhappenifweneverusedspaces?` - -Code style standards, just like any other language standard, are designed to make code easier to read and understand. - -Below, you will learn about the PEP 8 standard for the **Python** scientific programming language. This is the standard used by many **Python** users. - -## About the PEP 8 standard for Python - -PEP 8 is the style guide that is widely used in the **Python** community. This guide includes rules about naming objects, spacing rules and even how the code is laid out. - -**Python** is developed and maintained by an open source community, and thus, it is not possible to make code standards mandatory. Rather, community members choose to adopt PEP 8 recommendations whenever possible to contribute code that can easily be read and used by the greater community of users. - -PEP 8 covers many aspects of code readability, including: - -* naming conventions -* use of comments -* line lengths -* use of white space - -## PEP 8 naming conventions - -The text in this section is summarized from the PEP 8 Style Guide published by the Python Software Foundation. - -:::{tip} +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +#some data analysis with poor formatting +import pandas as pd +from datetime import datetime +def classify_precipitation(precip_list): + avg_precip=pd.Series(precip_list).mean() + if avg_precip<100: + return'Low' + elif avg_precip>=100 and avg_precip<=150: + return'Medium' + else: + return'High' +data={'location':['Station1','Station2','Station3','Station4'],'year':[2021,2021,2021,2021],'monthly_precipitation':[[50.0,70.0,90.0,80.0],[100.0,110.0,120.0,130.0],[150.0,160.0,170.0,180.0],[200.0,210.0,220.0,230.0]],'start_date':["2021-01-01","2021-01-01","2021-01-01","2021-01-01"]} +df=pd.DataFrame(data) +df['start_date']=pd.to_datetime(df['start_date']) +df['precipitation_category']=df['monthly_precipitation'].apply(classify_precipitation) +df +``` -**Terminology Teview** ++++ {"editable": true, "slideshow": {"slide_type": ""}} -First, let's review some terminology associated with naming conventions. +Notice that by adding docstrings, spacing to the the code.... -* **Lowercase letter:** `b` +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +# Built-in libraries are imported first +from datetime import datetime +import pandas as pd -* **Uppercase letter:** `B` +# Function to classify precipitation levels +def classify_precipitation(precip_list): + """Classify average monthly precipitation into low, medium, or high. + + Parameters + ---------- + precip_list : list of float + A list of monthly precipitation values (in mm). + + Returns + ------- + str + The precipitation category: 'Low', 'Medium', or 'High'. + """ + avg_precip = pd.Series(precip_list).mean() + + # Define the precipitation ranges + if avg_precip < 100: + return 'Low' + elif 100 <= avg_precip <= 150: + return 'Medium' + else: + return 'High' + + +# Sample data for precipitation values (in mm) for different locations +data = { + 'location': ['Station1', 'Station2', 'Station3', 'Station4'], + 'year': [2021, 2021, 2021, 2021], + 'monthly_precipitation': [ + [50.0, 70.0, 90.0, 80.0], # Station1 + [100.0, 110.0, 120.0, 130.0], # Station2 + [150.0, 160.0, 170.0, 180.0], # Station3 + [200.0, 210.0, 220.0, 230.0] # Station4 + ], + 'start_date': ["2021-01-01", "2021-01-01", "2021-01-01", "2021-01-01"] +} + +df = pd.DataFrame(data) +df['start_date'] = pd.to_datetime(df['start_date']) + +# Classify precipitation levels based on ranges +df['precipitation_category'] = df['monthly_precipitation'].apply(classify_precipitation) + +df +``` -* **lowercase:** `this is all lowercase words` ++++ {"editable": true, "slideshow": {"slide_type": ""}} -* **snake case:** when words are separated by underscores: `lower_case_with_underscores` +## How to Apply PEP 8 Code Style Standards -* **Uppercase:** All words are all uppercase letters: `UPPERCASE` +It may seem overwhelming to remember all the PEP 8 rules, but tools called **code formatters** can automatically apply these standards for you. -* **Snake case** upper case: `UPPER_CASE_WITH_UNDERSCORES` +### For `.py` Files -* **CamelCase:** Every word is capitalized so they visually stand out: `CapitalizedWords`. This is sometimes also referred to as CapWords or StudlyCaps. +Use popular tools like **Black** or **Ruff**: - * Note: When using acronyms in CamelCase, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError. +- **[Black](https://black.readthedocs.io/en/stable/)**: Automatically reformats code according to PEP 8. +- **[Ruff](https://docs.astral.sh/ruff/configuration/#jupyter-notebook-discovery)**: A linter and formatter that also supports import sorting with **isort**. -* **mixedCase:** (differs from CapitalizedWords by initial lowercase character!) +Both tools can be run manually or integrated into **pre-commit hooks** with Git to check your code before each commit. You can also configure them in your IDE (like VSCode, PyCharm, or Spyder) to format your code every time you save. -* **Capitalized_Words_With_Underscores:** This approach is not recommended. Use one convention and stick with it. +:::{note} +Ruff doesn’t fully support Jupyter/MyST markdown notebooks yet but can be integrated into a pre-commit workflow for GitHub repositories. ::: -### Use snake_case and all lower case for variable names - -It is recommended that you use standard naming conventions in your code. We suggest that you use **snake_case** and all lowercase letters in your code for variable and function names. Like this: -```python -variable_one -variable_two -``` - -### Use CamelCase or CapsCase for class names - -While regular variables and functions should use **snake_case**, PEP 8 -suggests that you use `CamelCase` for class definitions. - -```python -class PlotBasicObject(object): -``` +### For Jupyter Notebooks -### Avoid using single character letters that could be confused with numbers +For Jupyter Notebooks, try: +- **Notebook extensions**: Add extensions to your interface to format cells automatically. +- **nbQA**: A command-line tool that applies Black or Ruff to Jupyter Notebooks via the CLI. -Avoid using the characters: +### Running These Tools +These tools can be used in the following ways: +- **Manually**: Run on-demand to check and format your code. +- **Pre-commit hook**: Enforce code style checks before every commit. +- **IDE integration**: Automatically format code in your editor. -* 'l' (lowercase letter el), -* 'O' (uppercase letter oh), or -* 'I' (uppercase letter eye) +Using these tools ensures your code remains consistent, readable, and compliant with PEP 8, without memorizing all the rules. -as single-character variable names. +:::{admonition} Linter vs. Code Formatter +:class: note -These characters can be difficult to distinguish from numbers when -using certain font families. +- **Linter**: Checks your code and highlights issues but doesn’t automatically fix them. +- **Code Formatter**: Automatically reformats your code according to style rules. -For example, the letter `l` looks similar to the number `1`. - -## Comments and PEP 8 - -Documentation is an important part of writing great code. Below are some -of the important PEP 8 conventions associated with documentation. - -### 1. Python comments should have a space after the `#` sign with the first word capitalized +Ruff acts as both a linter and formatter, making it ideal for `.py` file workflows. +::: -Following the PEP8 style guide, single-line comments should -start with the `#` sign followed by a space. The first word of the comment should be capitalized. Like this: ++++ {"editable": true, "slideshow": {"slide_type": ""}} -`# This is a PEP 8 conforming comment` -The comment below does NOT conform to PEP 8 standards +## Why use code standards when writing Python code -`#this comment does not conform to PEP 8 standards` +Code standards make your code more readable and easier to maintain, just like writing conventions make text easier to read. Think about how we capitalize the first word of a sentence or add spaces between words—without those conventions, text would be hard to follow. Similarly, code with inconsistent formatting is difficult to understand and debug. + +For example: -### 2. Multi-line function comments (docstrings) +* Readable sentence: This is a sentence. +* Unformatted sentence: thisisasentence.withoutspacesitgetsconfusing. -Multi-line comments are most commonly used when creating docstrings. A docstring is the text that follows a function definition. This text helps you or someone using a function understand what the function does. +Using code standards like PEP 8 helps avoid such confusion, making code clearer and more professional. -Following the PEP8 style guide, you create a function docstring using three quotes `"""`. The first line of text following the quotes should be a short, concise description of what the function does. +### Some PEP 8 rules to remember -Below that, you can add as much text as you'd like that provides more detail about what the function does. +There is a style guide devoted to Python pep 8 standards that you can read [here](https://www.python.org/dev/peps/pep-0008/#naming-conventions). However, below are a handful of PEP 8 Rules that you can consider following when writing code. -example: +* Naming Conventions: Use **snake_case** for variables/functions and **CamelCase** for class names. ```python -def calculate_sum(rainfall, time="month"): - -"""Returns a single sum value of all precipitation. - -This function takes a Pandas DataFrame with time series as the index, -and calculates the total sum, aggregated by month. -""" -# Code here - -return the_total_sum +# This is a class definition +class MyClass: + """A class to process data and calculate statistics.""" + + # This is a function + def calculate_average(self, data_list): + """Calculate the average of a list of numbers.""" + total_sum = sum(data_list) + count = len(data_list) + return total_sum / count + +# Example variable names and function call +data_processor = DataProcessor() +numbers = [10, 20, 30, 40, 50] +average_value = data_processor.calculate_average(numbers) + +print(f"The average value is: {average_value}") ``` -## Line Length - -PEP 8 guidelines suggest that both code and comment lines should all be 79 characters wide (or less). This standard is common in other languages, such as **R**. +* Line Length: Limit all lines to 79 characters for better readability. :::{tip} Most text editors allow you to set up guides to see how long your code is. You can then use these guides to create line breaks in your code. ::: +* Comments: Add a space after the `#` sign and capitalize the first letter of a comment: -## Python PEP 8 rules for white space - -Some of the white space rules have already been discussed above. These including adding a single space after a comment `# Comment here`. - -There are also rules associated with spacing throughout your code. These include: +`# This is a PEP 8 conforming comment` -* **Add a blank line before a single-line comment (unless it is the first line of a cell in Jupyter Notebook)** Blank lines help to break up code visually . Consider reading this page: If all of the text was mashed together in one long paragraph, it would be more difficult to read. However, when you break the text up into related paragraphs, it becomes a lot easier to read. +* White Space: Add space between sections of code to improve clarity. +* Avoid using single-character letters that could be confused with numbers (ie the letter `l` looks similar to the number one `1` +* Add a blank line before a single-line comment (unless it is the first line of a cell in Jupyter Notebook) ```python +a = 1 -# Perform some math -a = 1+2 -b = 3+4 -c = a+b +# Here is a commment +b = 2 -# Read in and plot some -review_timeseries = pd.readcsv("pyos-data.csv") -review_timeseries.plot() ``` -The code below is more difficult to read as the spacing does not break up the text. - -```python -# Perform some math and do some things -a=1+2 -b=3+4 -c=a+b -data=pd.readcsv("pyos-data.csv") -data.plot() -``` - -* **Break up sections of code with white space:** As you are writing code, it's always good to consider readability and to break up sections of code accordingly. Breaking up your +* **Break up sections of code with white space:** Breaking up your code becomes even more important when you start working in Jupyter Notebooks which offer individual cells where you can add Markdown and code. ```python @@ -226,105 +233,60 @@ data.plot(ax=ax) plt.show() ``` -## Summary -- PEP 8 and Python +## PEP 8 naming conventions -The text above provides a broad overview of some of the PEP 8 guidelines and conventions for writing **Python** code. +:::{seealso} +The text in this section is summarized from the PEP 8 Style Guide published by the Python Software Foundation. -:::{important} -This page is not fully inclusive of all of the PEP 8 standards. ::: - -+++ - -## Tools for applying PEP 8 format to your code - -Many different tools can help you write code that is PEP 8 compliant. A tool that checks the format of your code is called a linter. - -Some linters will reformat your code so that it matches the standards. - -* [Black](https://black.readthedocs.io/en/stable/) has been a popular tool in the scientific Python ecosystem for several years. -* More recently, many people are moving to [ruff which now provides Jupyter support.](https://docs.astral.sh/ruff/configuration/#jupyter-notebook-discovery). Ruff is a perfect tool for you to use if you are developing your code in `.py` files. - - -:::{note} -Ruff doesn't currently work well with Jupyter / JupyText and myst markdown notebooks. But it can be easily configured into a .precommit workflow, which is used alongside Git and GitHub and will be applied every time you make a commit to a GitHub repo. -:::: - -The pyOpenSci community has been slowly adopting Ruff because it can run many code formatters with a single configuration file, making it a convenient and easy-to-use tool. - -:::{admonition} Linter vs. code formatter +:::{admonition} Terminology Review :class: tip -A code formatter is a tool that helps you modify your code to follow code standards. A linter checks your code and tells you if things need to be fixed, but it generally won't fix them for you. +First, let's review some terminology associated with naming conventions. + +* **Lowercase letter:** `b` +* **Uppercase letter:** `B` +* **lowercase:** `this is all lowercase words` +* **snake case:** when words are separated by underscores: `lower_case_with_underscores` +* **Uppercase:** All words are all uppercase letters: `UPPERCASE` +* **Snake case** upper case: `UPPER_CASE_WITH_UNDERSCORES` +* **CamelCase:** Every word is capitalized so they visually stand out: `CapitalizedWords`. This is sometimes also referred to as CapWords or StudlyCaps. + * Note: When using acronyms in CamelCase, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError. +* **mixedCase:** (differs from CapitalizedWords by initial lowercase character!) +* **Capitalized_Words_With_Underscores:** This approach is not recommended. Use one convention and stick with it. -Ruff is both a linter and code formatter which is why we like to use it when developing both software and .py file based workflows. ::: +++ {"editable": true, "slideshow": {"slide_type": ""}} -DRAFT!! - - -## Best Practices for Importing Python Packages In Scientific Code - -There are a set of best practices that you should follow when importing **Python** packages in your code. These best practices are outlined in the PEP 8 guidelines and apply to both **Python** scripts and to working in **Jupyter Notebook** files. - -## Import Python Libraries at the Top of Your Script or Notebook - -It is good practice to import all of the packages that you will need at the top of your **Python** script (.py file) or in the first code cell of a **Jupyter Notebook** file. - -This allows anyone looking at your code to immediately know what packages they need to have installed in order to successfully run the code. This rule also follows the PEP 8 conventions for **Python** code. - -```python -import os - -import pandas as pd -import numpy as np -``` - -Once you have imported all of the packages that you need to run your code in a script, you have access to all of the functions and classes defined in each package. - -If these imports are at the top of the script or **Jupyter Notebook** file, then you will be able to use those packages in any code lines that follow. +## Best practices for importing libraries -This means that if you import a package *after* running some code that requires that package, your code will not run successfully. +### Import Python libraries at the top of your code +It’s good practice to import all required libraries at the top of your **Python** script or in the first cell of a **Jupyter Notebook**. This helps anyone understand what packages are needed to run your code. It also follows PEP 8 conventions. -## 2. List Package Imports Following PEP 8 Standards: Most Common First, Followed By Third Party +### Organize your imports into groups -PEP 8 also specifies the order in which you should list your imports as follows (starting with the most commonly used): +PEP 8 recommends organizing imports in the following order: -> Imports should be grouped in the following order: -> Standard library imports. -> Related third party imports. -> Local application/library specific imports. -> You should put a blank line between each group of imports. +1. **Standard Library Imports**: These are built-in modules that come with Python, such as `os` and `glob`. You can find the full list [here](https://docs.python.org/3/library/index.html). +2. **Third-Party Imports**: Libraries that you install via `pip`, like `numpy` and `pandas`. +3. **Local Imports**: Code or modules specific to your project. -You may be wondering, what is a standard library import? The standard library imports are commonly used tools that are general in purpose and are part of the standard library of **Python**. These including things like: - -* **os**: handle files and directories. -* **glob**: create lists of files and directories for batch processing. - -In the PEP 8 order, other commonly used packages that are general in purpose will follow such as: - -* **numpy**: work with data in array formats. -* **matplotlib**: plot data. -* * **Pandas**: to work with tabular data. - -A PEP 8 order of imports for commonly used **Python** packages for science would look something like this: +Here’s an example following PEP 8 conventions: ```python import os import glob -import matplotlib.pyplot as plt import numpy as np import pandas as pd -``` +import matplotlib.pyplot as plt -Note that there is a space between the standard imports (`glob` and `os`) -and the rest of the third-party imports. +from my_module import my_function +``` -## What are Local application/library specific imports +### Why organize imports? -Local application / library specific imports refer to tool that you have created locally or just for your own work. +Organizing your imports this way ensures your code is readable and follows widely accepted practices. Importing libraries at the top also makes it easier to debug and see which dependencies are required to run the code. From f5fcf6fb3355f1a5fce4c4dab1d2cdd312c842be Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Tue, 8 Oct 2024 14:23:33 -0600 Subject: [PATCH 5/9] feat(fix): pep 8 lesson --- clean-modular-code/python-pep-8.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clean-modular-code/python-pep-8.md b/clean-modular-code/python-pep-8.md index 6f81e62..aa469f4 100644 --- a/clean-modular-code/python-pep-8.md +++ b/clean-modular-code/python-pep-8.md @@ -236,7 +236,7 @@ plt.show() ## PEP 8 naming conventions :::{seealso} -The text in this section is summarized from the PEP 8 Style Guide published by the Python Software Foundation. +For the entire pep-8 style guide see: PEP 8 Style Guide published by the Python Software Foundation. ::: @@ -270,7 +270,7 @@ It’s good practice to import all required libraries at the top of your **Pytho PEP 8 recommends organizing imports in the following order: -1. **Standard Library Imports**: These are built-in modules that come with Python, such as `os` and `glob`. You can find the full list [here](https://docs.python.org/3/library/index.html). +1. **Standard Library Imports**: These built-in modules come with Python, such as `os` and `glob`. You can find the full list [here](https://docs.python.org/3/library/index.html). 2. **Third-Party Imports**: Libraries that you install via `pip`, like `numpy` and `pandas`. 3. **Local Imports**: Code or modules specific to your project. From 90b8803f6f6e8e1c11b8d28987d63d465d1f25af Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Wed, 9 Oct 2024 13:26:33 -0600 Subject: [PATCH 6/9] feat(lesson): activity 3 and checks lessons --- .../activity-3/clean-code-activity-3.md | 240 + .../activity-3/clean-code-part-3.md | 176 - .../data/2020-joss-sample-data.json | 9356 ++++++++--------- .../python-function-checks.md | 100 + clean-modular-code/intro-clean-code.md | 6 +- 5 files changed, 5019 insertions(+), 4859 deletions(-) create mode 100644 clean-modular-code/activity-3/clean-code-activity-3.md delete mode 100644 clean-modular-code/activity-3/clean-code-part-3.md create mode 100644 clean-modular-code/checks-conditionals/python-function-checks.md diff --git a/clean-modular-code/activity-3/clean-code-activity-3.md b/clean-modular-code/activity-3/clean-code-activity-3.md new file mode 100644 index 0000000..ea827ed --- /dev/null +++ b/clean-modular-code/activity-3/clean-code-activity-3.md @@ -0,0 +1,240 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.16.4 +kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +# Activity 3: Tests & Checks for your code + +* In [activity 1](../activity-1/clean-code-activity-1), you took some code and made it cleaner using expressive variable names and docstrings to document the module. +* In [activity 2](../activity-2/clean-code-activity-2), you made your code more DRY ("Don't Repeat Yourself") using documented functions and conditionals. + +In this activity, you will build checks into your workflow to handle data processing "features". + + +### Real world data processing & workflows and edge cases +Real-world data rarely can be imported without "work arounds". You will often find unusual data entries and values you don't expect. Sometimes, these values are documented - for example, a 9999 may represent a missing value in a dataset. Other times, there are typos and other errors in the data that you need to handle. Sometimes, call these unusual values or instances in a dataset or workflow "edge cases". + +Writing robust code that handles unexpected values will make your code run smoothly and fail gracefully. This type of code, which combines functions (or classes) and checks within the functions that handle messy data, will make your code easier to maintain over time. + +:::{tip} +Using functions, classes, and methods (functions within a class) is a great first step in handling messy data. A function or method provides a modular unit you can test outside of the workflow for the edge cases you may encounter. Also, because a function is a modular unit, you can add elements to handle unexpected processing features as you build your workflow. +::: + +something about debuggers? +* https://jupyterlab.readthedocs.io/en/stable/user/debugger.html + +## Manage the unexpected + +In this activity, you will apply the following strategies: + +* [conditional statements](../checks-conditionals/python-conditionals) +* try/except blocks + +to process the JOSS citation data. + +:::{todo} +What branch is the lesson with try/except // ask for forgiveness, checks elements in?? +IN THIS PR: +https://github.com/pyOpenSci/lessons/pull/14/files#diff-7f4ff1b75e85d38f3955cca051e68e8746773c279b34c9a0a400b9c2dc1240ff +::: + +When you can, try to use the Pythonic approach of asking for forgiveness later (ie use try/except blocks) rather than conditional statements. + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +# This works but is less pythonic +def clean_title(title): + """Notice that this function checks explicitly to see if it's a list and then processes the data. + """ + if isinstance(title, list): + return title[0] + return title +``` + +## More "pythonic" - ask for forgiveness + +easier to ask for forgiveness + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +# This is the preferred way to catch an error +def clean_title(title): + """ + It's more Pythonic to try first and then ask for forgiveness later. + If you are writing tests this also makes your code easier to test. + """ + try: + return title[0] + except (TypeError, IndexError): + return title +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}, "tags": ["hide-output", "hide-cell"]} + +TODO - move this to activity 2 it doesn't belong in activity 3! + +### Applying functions to dataframe values - .apply + +The `.apply()` function in pandas allows you to apply any function to rows or columns in a `pandas.DataFrame`. For example, You can use it to perform operations on specific column or row values. When you use .apply(), you can specify whether you want to apply the function across columns (axis=0, the default) or across rows (axis=1). For example, if you want to apply a function to each row of a DataFrame, you would use df.apply(your_function, axis=1). This function is especially useful for applying logic that can’t be easily achieved with built-in pandas functions, allowing for more flexibility in data processing. + +You can use `.apply` in pandas as an efficient replacement for `for loops` to process row and column values in a df. + +```{code-cell} ipython3 +a=1 +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +The code below is an example of what your code might look like after completing activity 2. + +You can choose to work with this code, or you can use the code that you completed in activity 2. + +### What's changed + +For this activity, you now have a new data file to open in your list of .json files. This file has some unexpected "features" that you will need to ensure your code handles gracefully. + +Your goal is similar to ensure that the code below runs. + +:::{tip} +The code below will fail. You will likely want to use a debugger to determine why it's failing and get the code running. +::: + ++++ {"editable": true, "slideshow": {"slide_type": ""}, "tags": ["raises-exception"]} + +```python +import json +from pathlib import Path + +import pandas as pd + + +def load_clean_json(file_path, columns_to_keep): + """ + Load JSON data from a file. Drop unnecessary columns and normalize + to DataFrame. + + Parameters + ---------- + file_path : Path + Path to the JSON file. + columns_to_keep : list + List of columns to keep in the DataFrame. + + Returns + ------- + dict + Loaded JSON data. + """ + + with file_path.open("r") as json_file: + json_data = json.load(json_file) + normalized_data = pd.json_normalize(json_data) + + return normalized_data.filter(items=columns_to_keep) + + +def format_date(date_parts: list) -> str: + """ + Format date parts into a string. + + Parameters + ---------- + date_parts : list + List containing year, month, and day. + + Returns + ------- + str + Formatted date string. + """ + return f"{date_parts[0]}-{date_parts[1]:02d}-{date_parts[2]:02d}" + + +def clean_title(value): + """A function that removes a value contained in a list.""" + return value[0] + + +def process_published_date(date_parts): + """Parse a date provided as a list of values into a proper date format. + + Parameters + ---------- + date_parts : str or int + The elements of a date provided as a list from CrossRef + + Returns + ------- + pd.datetime + A date formatted as a pd.datetime object. + """ + + date_str = ( + f"{date_parts[0][0]}-{date_parts[0][1]:02d}-{date_parts[0][2]:02d}" + ) + return pd.to_datetime(date_str, format="%Y-%m-%d") + + +columns_to_keep = [ + "publisher", + "DOI", + "type", + "author", + "is-referenced-by-count", + "title", + "published.date-parts", +] + +data_dir = Path("data") + +all_papers_list = [] +for json_file in data_dir.glob("*.json"): + papers_df = load_clean_json(json_file, columns_to_keep) + + papers_df["title"] = papers_df["title"].apply(clean_title) + papers_df["published_date"] = papers_df["published.date-parts"].apply( + process_published_date + ) + + all_papers_list.append(papers_df) + +all_papers_df = pd.concat(all_papers_list, axis=0, ignore_index=True) + +print("Final shape of combined DataFrame:", all_papers_df.shape) +``` + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- + +``` + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- + +``` diff --git a/clean-modular-code/activity-3/clean-code-part-3.md b/clean-modular-code/activity-3/clean-code-part-3.md deleted file mode 100644 index 3c0dd4a..0000000 --- a/clean-modular-code/activity-3/clean-code-part-3.md +++ /dev/null @@ -1,176 +0,0 @@ ---- -jupytext: - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.16.4 -kernelspec: - display_name: Python 3 (ipykernel) - language: python - name: python3 ---- - -# Part 3 - Tests & Checks for your code - -In part 1, you took some code and worked to make it cleaner using expressive variable names. In part 2, you focused on making your code more DRY ("Don't Repeat Yourself"). - -In this section you will learn how to build in checks to your workflow to handle data processing "features". Messy data rarely are perfect when processing. you will most often find unusual data entries and values that you don't expdect. writing robust code that can handle unexpected values will make your code... - -Using functions is a great first step to handleing messy data because they rpovide a modular unit that you can test outside of the workflow for the edge cases that you may encounter. Also, because you have funtions you can add elements to them to handle unexpected processing features as you build out your workflow. - -You will learn about using: - -* conditional statements -* try/except blocks - -## Making checks Pythonic -The mantra of the zen of python includes : -“Easier to Ask for Forgiveness than Permission”) - -this means... - -```{code-cell} ipython3 -def clean_title(title): - """Notice that this function checks explicetiy to see if it's a list and then it proesses the data. - """ - if isinstance(title, list): - return title[0] - return title -``` - -## More "pythonic" - ask for forgiveness - -easier to ask for forgiveness - -```{code-cell} ipython3 -def clean_title(title): - """ - It's more pythonic to try first and then ask for forgiveneess later. - If you are writing tests this also makes your code easier to test. - """ - try: - return title[0] - except (TypeError, IndexError): - return title -``` - -### Applying functions to dataframe values - .apply - -The `.apply()` function in pandas allows you to apply any function to rows or columns in a `pandas.DataFrame`. For example, You can use it to perform operations on specific column or row values. When you use .apply(), you can specify whether you want to apply the function across columns (axis=0, the default) or across rows (axis=1). For example, if you want to apply a function to each row of a DataFrame, you would use df.apply(your_function, axis=1). This function is especially useful for applying logic that can’t be easily achieved with built-in pandas functions, allowing for more flexibility in data processing. - -You can use `.apply` in pandas as an efficient replacement for `for loops` to process row and column values in a df. - -```{code-cell} ipython3 - -``` - -Examine the code below. - -1. Identify what areas of the code are redundant. -2. Create pseudo code of the steps that are repeatied each time -3. identify sections of the code that could be combined into functions -4. When you are done with the above, refactor the code so that it is cleaner and more modular. - -```{code-cell} ipython3 -import json -from pathlib import Path - -import pandas as pd - - -def load_clean_json(file_path, columns_to_keep): - """ - Load JSON data from a file. Drop unnecessary columns and normalize - to DataFrame. - - Parameters - ---------- - file_path : Path - Path to the JSON file. - columns_to_keep : list - List of columns to keep in the DataFrame. - - Returns - ------- - dict - Loaded JSON data. - """ - - with file_path.open("r") as json_file: - json_data = json.load(json_file) - normalized_data = pd.json_normalize(json_data) - - return normalized_data.filter(items=columns_to_keep) - - -def format_date(date_parts: list) -> str: - """ - Format date parts into a string. - - Parameters - ---------- - date_parts : list - List containing year, month, and day. - - Returns - ------- - str - Formatted date string. - """ - return f"{date_parts[0]}-{date_parts[1]:02d}-{date_parts[2]:02d}" - - -def clean_title(value): - """A function that removes a value contained in a list.""" - return value[0] - - -def process_published_date(date_parts): - """Parse a date provided as a list of values into a proper date format. - - Parameters - ---------- - date_parts : str or int - The elements of a date provided as a list from CrossRef - - Returns - ------- - pd.datetime - A date formatted as a pd.datetime object. - """ - - date_str = ( - f"{date_parts[0][0]}-{date_parts[0][1]:02d}-{date_parts[0][2]:02d}" - ) - return pd.to_datetime(date_str, format="%Y-%m-%d") - - -columns_to_keep = [ - "publisher", - "DOI", - "type", - "author", - "is-referenced-by-count", - "title", - "published.date-parts", -] - -current_dir = Path(__file__).parent -data_dir = current_dir / "data" - -all_papers_list = [] -for json_file in data_dir.glob("*.json"): - papers_df = load_clean_json(json_file, columns_to_keep) - - papers_df["title"] = papers_df["title"].apply(clean_title) - papers_df["published_date"] = papers_df["published.date-parts"].apply( - process_published_date - ) - - all_papers_list.append(papers_df) - -all_papers_df = pd.concat(all_papers_list, axis=0, ignore_index=True) - -print("Final shape of combined DataFrame:", all_papers_df.shape) -``` diff --git a/clean-modular-code/activity-3/data/2020-joss-sample-data.json b/clean-modular-code/activity-3/data/2020-joss-sample-data.json index 90dd9d2..5761dbc 100644 --- a/clean-modular-code/activity-3/data/2020-joss-sample-data.json +++ b/clean-modular-code/activity-3/data/2020-joss-sample-data.json @@ -1,4853 +1,4517 @@ [ - { - "indexed": { - "date-parts": [ - [ - twentytwentytwo, - three, - 28 - ] - ], - "date-time": "2022-03-28T23:34:11Z", - "timestamp": 1648510451692 - }, - "reference-count": 28, - "publisher": "The Open Journal", - "issue": "53", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ], - "date-time": "2020-09-26T00:00:00Z", - "timestamp": 1601078400000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ], - "date-time": "2020-09-26T00:00:00Z", - "timestamp": 1601078400000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ], - "date-time": "2020-09-26T00:00:00Z", - "timestamp": 1601078400000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ] - }, - "DOI": "10.21105/joss.02583", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ], - "date-time": "2020-09-26T12:21:07Z", - "timestamp": 1601122867000 - }, - "page": "2583", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": "emba: R package for analysis and visualization of biomarkers in boolean model ensembles", - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-3609-8674", - "authenticated-orcid": false, - "given": "John", - "family": "Zobolas", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-1171-9876", - "authenticated-orcid": false, - "given": "Martin", - "family": "Kuiper", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-3357-425X", - "authenticated-orcid": false, - "given": "\u00c5smund", - "family": "Flobak", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fgene.2016.00094" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1038/ncb1497" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1038/nbt.2284" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1186/s12859-016-1287-z" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1158/0008-5472.CAN-17-0078" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1371/journal.pcbi.1004426" - }, - { - "key": "ref7", - "doi-asserted-by": "publisher", - "DOI": "10.1016/J.CELS.2018.10.013" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1186/1752-0509-6-96" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btw682" - }, - { - "key": "ref10", - "doi-asserted-by": "publisher", - "DOI": "10.1038/nmeth.2016" - }, - { - "key": "ref11", - "doi-asserted-by": "publisher", - "DOI": "10.1021/bi902202q" - }, - { - "key": "ref12", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btq124" - }, - { - "key": "ref13", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fphys.2018.01605" - }, - { - "key": "ref14", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fphys.2018.00646" - }, - { - "key": "ref15", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fphys.2018.00680" - }, - { - "key": "ref16", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btv013" - }, - { - "key": "ref17", - "doi-asserted-by": "publisher", - "DOI": "10.1007/978-3-319-67471-1_20" - }, - { - "key": "ref18", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.molmed.2017.08.003" - }, - { - "key": "ref19", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btx123" - }, - { - "key": "ref20", - "doi-asserted-by": "publisher", - "DOI": "10.1186/1752-0509-6-133" - }, - { - "key": "ref21", - "doi-asserted-by": "publisher", - "DOI": "10.1002/psp4.12225" - }, - { - "key": "ref22", - "doi-asserted-by": "publisher", - "DOI": "10.1088/1478-3975/9/5/055001" - }, - { - "key": "ref23", - "doi-asserted-by": "publisher", - "DOI": "10.1186/s12864-019-6413-7" - }, - { - "key": "ref24", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btaa561" - }, - { - "key": "ref25", - "unstructured": "usefun: A Collection of Useful Functions by John, Zobolas, John, R package version 0.4.7, https://github.com/bblodfon/usefun, 2020" - }, - { - "key": "ref26", - "unstructured": "Zobolas, John, Ensemble boolean model analyses related to drug prediction performance, 2020, GitHub, https://github.com/bblodfon/gitsbe-model-analysis" - }, - { - "key": "ref27", - "unstructured": "Zobolas, John, DrugLogics software documentation, 2020, GitHub Pages, https://druglogics.github.io/druglogics-doc/" - }, - { - "key": "ref28", - "unstructured": "Zobolas, John, emba package website, 2020, GitHub Pages, https://bblodfon.github.io/emba/" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02583.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ], - "date-time": "2020-09-26T12:21:12Z", - "timestamp": 1601122872000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02583" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ] - }, - "references-count": 28, - "journal-issue": { - "issue": "53", - "published-online": { - "date-parts": [ - [ - 2020, - 9 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02583" - ], - "URL": "http://dx.doi.org/10.21105/joss.02583", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4043085\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2583", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 9, - 26 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2023, - 5, - 19 - ] - ], - "date-time": "2023-05-19T09:31:24Z", - "timestamp": 1684488684122 - }, - "reference-count": 12, - "publisher": "The Open Journal", - "issue": "46", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ], - "date-time": "2020-02-10T00:00:00Z", - "timestamp": 1581292800000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ], - "date-time": "2020-02-10T00:00:00Z", - "timestamp": 1581292800000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ], - "date-time": "2020-02-10T00:00:00Z", - "timestamp": 1581292800000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - 2020, - 2, - "ten" - ] - }, - "DOI": "10.21105/joss.02013", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ], - "date-time": "2020-02-10T18:47:10Z", - "timestamp": 1581360430000 - }, - "page": "2013", - "source": "Crossref", - "is-referenced-by-count": 6, - "title": [ - "thresholdmodeling: A Python package for modeling excesses over a threshold using the Peak-Over-Threshold Method and the Generalized Pareto Distribution" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-5829-7711", - "authenticated-orcid": false, - "given": "Iago", - "family": "Lemos", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-0170-6083", - "authenticated-orcid": false, - "given": "Ant\u00f4nio", - "family": "Lima", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-8166-5666", - "authenticated-orcid": false, - "given": "Marcus", - "family": "Duarte", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1007/978-1-4471-3675-0" - }, - { - "key": "ref2", - "unstructured": ": Generalized Pareto Distribution and Peaks Over Threshold, Ribatet, Mathieu and Dutang, Christophe, 2019, package version 1.1-7, https://cran.r-project.org/web/packages/POT/index.html" - }, - { - "key": "ref3", - "unstructured": ": Extreme Value Analysis, Gilleland, Eric, 2019, package version 2.0-11, https://cran.r-project.org/web/packages/extRemes/index.html" - }, - { - "key": "ref4", - "unstructured": ": Functions for Extreme Value Distributions, Stephenson, Alec, 2018, package version 2.3-3, https://cran.r-project.org/web/packages/evd/index.html" - }, - { - "key": "ref5", - "unstructured": "Tan, Hwei-Yang, Analysis of Corrosion Data for Integrity Assessments, Thesis for the Degree of Doctor of Philosophy, 2017, Brunel University London, 2017" - }, - { - "key": "ref6", - "unstructured": "Bommier, Esther, Peaks-Over-Threshold Modelling of Environmental Data, Examensarbete i matematik, Uppsala University, 2014" - }, - { - "key": "ref7", - "unstructured": "Rydman, Max, Application of the Peaks-Over-Threshold Method on Insurance Data, Examensarbete i matematik, Uppsala University, 2018" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1016/S0309-1708(02)00056-8" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1017/CBO9780511529443" - }, - { - "key": "ref10", - "doi-asserted-by": "publisher", - "DOI": "10.6028/jres.099.028" - }, - { - "key": "ref11", - "unstructured": "Scipy, scipy.stats.genpareto, 2019, https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.genpareto.html" - }, - { - "key": "ref12", - "unstructured": "Correoso, Kiko, scikit-extremes, 2019, https://github.com/kikocorreoso/scikit-extremes" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02013/10.21105.joss.02013.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ], - "date-time": "2020-02-10T18:47:15Z", - "timestamp": 1581360435000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02013" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ] - }, - "references-count": 12, - "journal-issue": { - "issue": "46", - "published-online": { - "date-parts": [ - [ - 2020, - 2 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02013" - ], - "URL": "http://dx.doi.org/10.21105/joss.02013", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3661338\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2013", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 2, - 10 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2024, - 3, - 18 - ] - ], - "date-time": "2024-03-18T11:29:06Z", - "timestamp": 1710761346762 - }, - "reference-count": 31, - "publisher": "The Open Journal", - "issue": "51", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ], - "date-time": "2020-07-04T00:00:00Z", - "timestamp": 1593820800000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ], - "date-time": "2020-07-04T00:00:00Z", - "timestamp": 1593820800000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ], - "date-time": "2020-07-04T00:00:00Z", - "timestamp": 1593820800000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - "7x", - "4x" - ] - ] - }, - "DOI": "10.21105/joss.01906", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ], - "date-time": "2020-07-04T16:51:59Z", - "timestamp": 1593881519000 - }, - "page": "1906", - "source": "Crossref", - "is-referenced-by-count": 4, - "title": [ - "FLAM: Fast Linear Algebra in MATLAB - Algorithms for Hierarchical Matrices" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0001-5450-4966", - "authenticated-orcid": false, - "given": "Kenneth", - "family": "Ho", - "sequence": "first", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s10915-013-9714-z" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.21105/joss.01167" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s10444-020-09774-2" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.jcp.2016.12.051" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.jcp.2018.12.014" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1017/jfm.2017.150" - }, - { - "key": "ref7", - "doi-asserted-by": "publisher", - "DOI": "10.4310/CMS.2020.v18.n1.a4" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1137/15M1010117" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s11464-012-0188-3" - }, - { - "key": "ref10", - "doi-asserted-by": "publisher", - "DOI": "10.4208/cicp.150215.260615sw" - }, - { - "key": "ref11", - "doi-asserted-by": "publisher", - "DOI": "10.1016/0021-9991(87)90140-9" - }, - { - "key": "ref12", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s006070050015" - }, - { - "key": "ref13", - "doi-asserted-by": "publisher", - "DOI": "10.1137/120866683" - }, - { - "key": "ref14", - "doi-asserted-by": "publisher", - "DOI": "10.1137/120902677" - }, - { - "key": "ref15", - "doi-asserted-by": "publisher", - "DOI": "10.1002/cpa.21577" - }, - { - "key": "ref16", - "doi-asserted-by": "publisher", - "DOI": "10.1002/cpa.21582" - }, - { - "key": "ref17", - "doi-asserted-by": "publisher", - "DOI": "10.1137/16M1081920" - }, - { - "key": "ref18", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.enganabound.2019.06.020" - }, - { - "key": "ref19", - "doi-asserted-by": "publisher", - "DOI": "10.1186/s40687-017-0100-6" - }, - { - "key": "ref20", - "doi-asserted-by": "publisher", - "DOI": "10.1349/ddlp.2447" - }, - { - "key": "ref21", - "doi-asserted-by": "publisher", - "DOI": "10.1137/060662253" - }, - { - "key": "ref22", - "doi-asserted-by": "publisher", - "DOI": "10.1137/19M1288048" - }, - { - "key": "ref23", - "doi-asserted-by": "publisher", - "DOI": "10.1137/15M1024500" - }, - { - "key": "ref24", - "unstructured": "Minden, V. L., Data-sparse algorithms for structured matrices, Stanford University, 2017" - }, - { - "key": "ref25", - "doi-asserted-by": "publisher", - "DOI": "10.1137/16M1095949" - }, - { - "key": "ref26", - "doi-asserted-by": "publisher", - "DOI": "10.1137/17M1116477" - }, - { - "key": "ref27", - "doi-asserted-by": "publisher", - "DOI": "10.1145/2930660" - }, - { - "key": "ref28", - "doi-asserted-by": "publisher", - "DOI": "10.4310/CMS.2019.v17.n6.a7" - }, - { - "key": "ref29", - "unstructured": "Wang, S., Efficient high-order integral equation methods for the heat equation, New Jersey Institute of Technology, 2016" - }, - { - "key": "ref30", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s10915-018-0872-x" - }, - { - "key": "ref31", - "doi-asserted-by": "publisher", - "DOI": "10.1002/nla.691" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.01906/10.21105.joss.01906.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ], - "date-time": "2020-07-04T16:52:02Z", - "timestamp": 1593881522000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.01906" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ] - }, - "references-count": 31, - "journal-issue": { - "issue": "51", - "published-online": { - "date-parts": [ - [ - 2020, - 7 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.01906" - ], - "URL": "http://dx.doi.org/10.21105/joss.01906", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3930385\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/1906", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 7, - 4 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 3, - 29 - ] - ], - "date-time": "2022-03-29T15:34:34Z", - "timestamp": 1648568074460 - }, - "reference-count": 14, - "publisher": "The Open Journal", - "issue": "53", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ], - "date-time": "2020-09-07T00:00:00Z", - "timestamp": 1599436800000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ], - "date-time": "2020-09-07T00:00:00Z", - "timestamp": 1599436800000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ], - "date-time": "2020-09-07T00:00:00Z", - "timestamp": 1599436800000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - 2020, - 9, - 7 - ] - }, - "DOI": "10.21105/joss.02331", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ], - "date-time": "2020-09-07T23:51:02Z", - "timestamp": 1599522662000 - }, - "page": "2331", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": [ - "Flint A simulator for biological and physiological models in ordinary and stochastic differential equations" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-7074-4561", - "authenticated-orcid": false, - "given": "Takeshi", - "family": "Abe", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0001-5519-4306", - "authenticated-orcid": false, - "given": "Yoshiyuki", - "family": "Asai", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fphys.2015.00251" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.14326/abe.3.50" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1109/SAINT.2012.40" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1137/S0036144500378302" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.pbiomolbio.2004.01.004" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btg015" - }, - { - "key": "ref7", - "doi-asserted-by": "publisher", - "DOI": "10.1145/1089014.1089020" - }, - { - "key": "ref8", - "unstructured": "Madsen, K. and Nielsen, H. B. and Tingleff, O., Methods for Non-Linear Least Squares Problems (2nd ed.), 2004, 60, Informatics and Mathematical Modelling, Technical University of Denmark, DTU, Richard Petersens Plads, Building 321, DK-2800 Kgs. Lyngby" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.3389/fphys.2010.00164" - }, - { - "key": "ref10", - "doi-asserted-by": "publisher", - "DOI": "10.1093/bioinformatics/btl485" - }, - { - "key": "ref11", - "doi-asserted-by": "publisher", - "DOI": "10.1126/science.290.5495.1358" - }, - { - "key": "ref12", - "doi-asserted-by": "publisher", - "DOI": "10.1073/pnas.0406841102" - }, - { - "key": "ref13", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.imr.2015.12.004" - }, - { - "key": "ref14", - "unstructured": "Williams, Thomas and Kelley, Colin and Merrit, E. A. and al., Gnuplot 5.2: an interactive plotting program, sep, 2017, http://www.gnuplot.info/, 9" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02331.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ], - "date-time": "2020-09-07T23:51:05Z", - "timestamp": 1599522665000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02331" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ] - }, - "references-count": 14, - "journal-issue": { - "issue": "53", - "published-online": { - "date-parts": [ - [ - 2020, - 9 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02331" - ], - "URL": "http://dx.doi.org/10.21105/joss.02331", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4017040\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2331", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 9, - 7 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2024, - 9, - 6 - ] - ], - "date-time": "2024-09-06T04:37:51Z", - "timestamp": 1725597471362 - }, - "reference-count": 21, - "publisher": "The Open Journal", - "issue": "53", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ], - "date-time": "2020-09-02T00:00:00Z", - "timestamp": 1599004800000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ], - "date-time": "2020-09-02T00:00:00Z", - "timestamp": 1599004800000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ], - "date-time": "2020-09-02T00:00:00Z", - "timestamp": 1599004800000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ] - }, - "DOI": "10.21105/joss.02165", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ], - "date-time": "2020-09-02T13:33:23Z", - "timestamp": 1599053603000 - }, - "page": "2165", - "source": "Crossref", - "is-referenced-by-count": 4, - "title": [ - "A Comprehensive and Collaborative Modeling\nFramework for Complex and Evolving Systems: Utopia" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-4667-3652", - "authenticated-orcid": false, - "given": "Lukas", - "family": "Riedel", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0001-6343-3004", - "authenticated-orcid": false, - "given": "Benjamin", - "family": "Herdeanu", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0001-7787-9496", - "authenticated-orcid": false, - "given": "Harald", - "family": "Mack", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-3858-0904", - "authenticated-orcid": false, - "given": "Yunus", - "family": "Sevinchan", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Julian", - "family": "Weninger", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "issue": "1", - "key": "holland_studying_2006", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s11424-006-0001-z", - "article-title": "Studying complex adaptive\nsystems", - "volume": "19", - "author": "Holland", - "year": "2006", - "unstructured": "Holland, J. H. (2006). Studying\ncomplex adaptive systems. Journal of Systems Science and Complexity,\n19(1), 1\u20138.\nhttps://doi.org/10.1007/s11424-006-0001-z", - "journal-title": "Journal of Systems Science and\nComplexity", - "ISSN": "http://id.crossref.org/issn/1559-7067", - "issn-type": "print" - }, - { - "issue": "3", - "key": "wolfram_statistical_1983", - "doi-asserted-by": "publisher", - "DOI": "10.1103/RevModPhys.55.601", - "article-title": "Statistical mechanics of cellular\nautomata", - "volume": "55", - "author": "Wolfram", - "year": "1983", - "unstructured": "Wolfram, S. (1983). Statistical\nmechanics of cellular automata. Reviews of Modern Physics, 55(3),\n601\u2013644.\nhttps://doi.org/10.1103/RevModPhys.55.601", - "journal-title": "Reviews of Modern Physics" - }, - { - "issue": "2", - "key": "macal_everything_2016", - "doi-asserted-by": "publisher", - "DOI": "10.1057/jos.2016.7", - "article-title": "Everything you need to know about agent-based\nmodelling and simulation", - "volume": "10", - "author": "Macal", - "year": "2016", - "unstructured": "Macal, C. M. (2016). Everything you\nneed to know about agent-based modelling and simulation. Journal of\nSimulation, 10(2), 144\u2013156.\nhttps://doi.org/10.1057/jos.2016.7", - "journal-title": "Journal of Simulation", - "ISSN": "http://id.crossref.org/issn/1747-7778", - "issn-type": "print" - }, - { - "key": "the_hdf_group_hierarchical_1997", - "article-title": "Hierarchical Data Format, Version\n5", - "author": "The HDF Group", - "year": "1997", - "unstructured": "The HDF Group. (1997). Hierarchical\nData Format, Version 5.\nhttp://www.hdfgroup.org/HDF5/" - }, - { - "issue": "1", - "key": "albert_statistical_2002", - "doi-asserted-by": "publisher", - "DOI": "10.1103/RevModPhys.74.47", - "article-title": "Statistical mechanics of complex\nnetworks", - "volume": "74", - "author": "Albert", - "year": "2002", - "unstructured": "Albert, R., & Barab\u00e1si, A.-L.\n(2002). Statistical mechanics of complex networks. Reviews of Modern\nPhysics, 74(1), 47\u201397.\nhttps://doi.org/10.1103/RevModPhys.74.47", - "journal-title": "Reviews of Modern Physics" - }, - { - "issue": "4", - "key": "boccaletti_complex_2006", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.physrep.2005.10.009", - "article-title": "Complex networks: Structure and\ndynamics", - "volume": "424", - "author": "Boccaletti", - "year": "2006", - "unstructured": "Boccaletti, S., Latora, V., Moreno,\nY., Chavez, M., & Hwang, D.-U. (2006). Complex networks: Structure\nand dynamics. Physics Reports, 424(4), 175\u2013308.\nhttps://doi.org/10.1016/j.physrep.2005.10.009", - "journal-title": "Physics Reports", - "ISSN": "http://id.crossref.org/issn/0370-1573", - "issn-type": "print" - }, - { - "issue": "02n03", - "key": "chopard_cellular_2002", - "doi-asserted-by": "publisher", - "DOI": "10.1142/S0219525902000602", - "article-title": "Cellular automata and lattice boltzmann\ntechniques: An approach to model and simulate complex\nsystems", - "volume": "05", - "author": "Chopard", - "year": "2002", - "unstructured": "Chopard, B., Dupuis, A., Masselot,\nA., & Luthi, P. (2002). Cellular automata and lattice boltzmann\ntechniques: An approach to model and simulate complex systems. Advances\nin Complex Systems, 05(02n03), 103\u2013246.\nhttps://doi.org/10.1142/S0219525902000602", - "journal-title": "Advances in Complex Systems", - "ISSN": "http://id.crossref.org/issn/0219-5259", - "issn-type": "print" - }, - { - "issue": "4", - "key": "storer_bridging_2017", - "doi-asserted-by": "publisher", - "DOI": "10.1145/3084225", - "article-title": "Bridging the Chasm: A Survey of Software\nEngineering Practice in Scientific Programming", - "volume": "50", - "author": "Storer", - "year": "2017", - "unstructured": "Storer, T. (2017). Bridging the\nChasm: A Survey of Software Engineering Practice in Scientific\nProgramming. ACM Computing Surveys (CSUR), 50(4).\nhttps://doi.org/10.1145/3084225", - "journal-title": "ACM Computing Surveys (CSUR)", - "ISSN": "http://id.crossref.org/issn/0360-0300", - "issn-type": "print" - }, - { - "issue": "1", - "key": "levin_2003_complex", - "doi-asserted-by": "publisher", - "DOI": "10.1090/S0273-0979-02-00965-5", - "article-title": "Complex adaptive systems: Exploring the\nknown, the unknown and the unknowable", - "volume": "40", - "author": "Levin", - "year": "2003", - "unstructured": "Levin, S. (2003). Complex adaptive\nsystems: Exploring the known, the unknown and the unknowable. Bulletin\nof the American Mathematical Society, 40(1), 3\u201319.\nhttps://doi.org/10.1090/S0273-0979-02-00965-5", - "journal-title": "Bulletin of the American Mathematical\nSociety" - }, - { - "key": "wilensky_1999_netlogo", - "article-title": "NetLogo", - "author": "Wilensky", - "year": "1999", - "unstructured": "Wilensky, U. (1999). NetLogo. Center\nfor Connected Learning and Computer-Based Modeling, Northwestern\nUniversity. Evanston, IL.\nhttp://ccl.northwestern.edu/netlogo/" - }, - { - "issue": "52", - "key": "sevinchan_2020_dantro", - "doi-asserted-by": "publisher", - "DOI": "10.21105/joss.02316", - "article-title": "dantro: A Python package for handling,\ntransforming, and visualizing hierarchically structured\ndata", - "volume": "5", - "author": "Sevinchan", - "year": "2020", - "unstructured": "Sevinchan, Y., Herdeanu, B., &\nTraub, J. (2020). dantro: A Python package for handling, transforming,\nand visualizing hierarchically structured data. Journal of Open Source\nSoftware, 5(52), 2316.\nhttps://doi.org/10.21105/joss.02316", - "journal-title": "Journal of Open Source\nSoftware" - }, - { - "key": "sevinchan_2019_paramspace", - "article-title": "Paramspace, Version 2.3.1", - "author": "Sevinchan", - "year": "2019", - "unstructured": "Sevinchan, Y. (2019). Paramspace,\nVersion 2.3.1. Python Package Index (PyPI).\nhttps://pypi.org/project/paramspace/" - }, - { - "key": "sevinchan_2020_iccs", - "isbn-type": "print", - "doi-asserted-by": "publisher", - "DOI": "10.1007/978-3-030-50436-6_32", - "article-title": "Boosting group-level synergies by using a\nshared modeling framework", - "volume": "12143", - "author": "Sevinchan", - "year": "2020", - "unstructured": "Sevinchan, Y., Herdeanu, B., Mack,\nH., Riedel, L., & Roth, K. (2020). Boosting group-level synergies by\nusing a shared modeling framework. In V. V. Krzhizhanovskaya, G.\nZ\u00e1vodszky, M. H. Lees, J. J. Dongarra, P. M. A. Sloot, S. Brissos, &\nJ. Teixeira (Eds.), Computational Science \u2013 ICCS 2020 (Vol. 12143, pp.\n442\u2013456). Springer International Publishing.\nhttps://doi.org/10.1007/978-3-030-50436-6_32", - "ISBN": "http://id.crossref.org/isbn/9783030504366", - "journal-title": "Computational Science \u2013 ICCS\n2020" - }, - { - "key": "herdeanu_2020_arxiv", - "article-title": "Utopia: A comprehensive modeling framework\nfor complex and evolving systems", - "author": "Herdeanu", - "year": "2020", - "unstructured": "Herdeanu, B., Mack, H., Riedel, L.,\n& Sevinchan, Y. (2020). Utopia: A comprehensive modeling framework\nfor complex and evolving systems. In\npreparation." - }, - { - "issue": "10", - "key": "kanewala_2014_testing", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.infsof.2014.05.006", - "article-title": "Testing scientific software: A systematic\nliterature review", - "volume": "56", - "author": "Kanewala", - "year": "2014", - "unstructured": "Kanewala, U., & Bieman, J. M.\n(2014). Testing scientific software: A systematic literature review.\nInformation and Software Technology, 56(10), 1219\u20131232.\nhttps://doi.org/10.1016/j.infsof.2014.05.006", - "journal-title": "Information and Software\nTechnology" - }, - { - "issue": "42", - "key": "vahdati_agentsjl_2019", - "doi-asserted-by": "publisher", - "DOI": "10.21105/joss.01611", - "article-title": "Agents.jl: Agent-based modeling framework in\nJulia", - "volume": "4", - "author": "Vahdati", - "year": "2019", - "unstructured": "Vahdati, A. (2019). Agents.jl:\nAgent-based modeling framework in Julia. Journal of Open Source\nSoftware, 4(42), 1611.\nhttps://doi.org/10.21105/joss.01611", - "journal-title": "Journal of Open Source\nSoftware", - "ISSN": "http://id.crossref.org/issn/2475-9066", - "issn-type": "print" - }, - { - "key": "cardinot_evoplex_2019", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.softx.2019.02.009", - "article-title": "Evoplex: A platform for agent-based modeling\non networks", - "volume": "9", - "author": "Cardinot", - "year": "2019", - "unstructured": "Cardinot, M., O\u2019Riordan, C.,\nGriffith, J., & Perc, M. (2019). Evoplex: A platform for agent-based\nmodeling on networks. SoftwareX, 9, 199\u2013204.\nhttps://doi.org/10.1016/j.softx.2019.02.009", - "journal-title": "SoftwareX", - "ISSN": "http://id.crossref.org/issn/2352-7110", - "issn-type": "print" - }, - { - "key": "masad_2015_mesa", - "doi-asserted-by": "publisher", - "DOI": "10.25080/Majora-7b98e3ed-009", - "article-title": "Mesa: An agent-based modeling\nframework", - "author": "Masad", - "year": "2015", - "unstructured": "Masad, D., & Kazil, J. (2015).\nMesa: An agent-based modeling framework. In K. Huff & J. Bergstra\n(Eds.), Proceedings of the 14th Python in Science Conference (pp.\n51\u201358).\nhttps://doi.org/10.25080/Majora-7b98e3ed-009", - "journal-title": "Proceedings of the 14th Python in Science\nConference" - }, - { - "key": "Drossel1992", - "doi-asserted-by": "publisher", - "DOI": "10.1103/PhysRevLett.69.1629", - "article-title": "Self-organized critical forest-fire\nmodel", - "volume": "69", - "author": "Drossel", - "year": "1992", - "unstructured": "Drossel, B., & Schwabl, F.\n(1992). Self-organized critical forest-fire model. Phys. Rev. Lett., 69,\n1629\u20131632.\nhttps://doi.org/10.1103/PhysRevLett.69.1629", - "journal-title": "Phys. Rev. Lett." - }, - { - "issue": "2", - "key": "sanderson_armadillo_2016", - "doi-asserted-by": "publisher", - "DOI": "10.21105/joss.00026", - "article-title": "Armadillo: A template-based C++ library for\nlinear algebra", - "volume": "1", - "author": "Sanderson", - "year": "2016", - "unstructured": "Sanderson, C., & Curtin, R.\n(2016). Armadillo: A template-based C++ library for linear algebra.\nJournal of Open Source Software, 1(2), 26.\nhttps://doi.org/10.21105/joss.00026", - "journal-title": "Journal of Open Source\nSoftware" - }, - { - "key": "sanderson_matrix_2018", - "isbn-type": "print", - "doi-asserted-by": "publisher", - "DOI": "10.1007/978-3-319-96418-8_50", - "article-title": "A\u00a0user-friendly\u00a0hybrid\nsparse\u00a0matrix\u00a0class\u00a0in\u00a0C++", - "author": "Sanderson", - "year": "2018", - "unstructured": "Sanderson, C., & Curtin, R.\n(2018). A\u00a0user-friendly\u00a0hybrid sparse\u00a0matrix\u00a0class\u00a0in\u00a0C++. In J. H.\nDavenport, M. Kauers, G. Labahn, & J. Urban (Eds.), Mathematical\nsoftware \u2013 ICMS 2018 (pp. 422\u2013430). Springer International Publishing.\nhttps://doi.org/10.1007/978-3-319-96418-8_50", - "ISBN": "http://id.crossref.org/isbn/9783319964188", - "journal-title": "Mathematical software \u2013 ICMS\n2018" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02165.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2022, - 8, - 25 - ] - ], - "date-time": "2022-08-25T16:33:26Z", - "timestamp": 1661445206000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02165" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ] - }, - "references-count": 21, - "journal-issue": { - "issue": "53", - "published-online": { - "date-parts": [ - [ - 2020, - 9 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02165" - ], - "URL": "http://dx.doi.org/10.21105/joss.02165", - "relation": { - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2165", - "asserted-by": "subject" - } - ], - "references": [ - { - "id-type": "doi", - "id": "10.5281/zenodo.4011979", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 9, - 2 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 3, - 30 - ] - ], - "date-time": "2022-03-30T02:07:11Z", - "timestamp": 1648606031350 - }, - "reference-count": 12, - "publisher": "The Open Journal", - "issue": "52", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ], - "date-time": "2020-08-21T00:00:00Z", - "timestamp": 1597968000000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ], - "date-time": "2020-08-21T00:00:00Z", - "timestamp": 1597968000000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ], - "date-time": "2020-08-21T00:00:00Z", - "timestamp": 1597968000000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ] - }, - "DOI": "10.21105/joss.02404", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ], - "date-time": "2020-08-21T10:36:10Z", - "timestamp": 1598006170000 - }, - "page": "2404", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": 9999, - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0003-3662-7203", - "authenticated-orcid": false, - "given": "Mathew", - "family": "Schwartz", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-8292-7189", - "authenticated-orcid": false, - "given": "Todd", - "family": "Pataky", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Cyril", - "family": "Donnelly", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1145/2448196.2448199" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1145/2822013.2822039" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1109/tnsre.2013.2291907" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.23919/eusipco.2017.8081163" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1109/tnsre.2019.2907483" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1145/956750.956777" - }, - { - "key": "ref7", - "doi-asserted-by": "crossref", - "unstructured": "Statstream: Statistical monitoring of thousands of data streams in real time, Zhu, Yunyue and Shasha, Dennis, VLDB\u201902: Proceedings of the 28th International Conference on Very Large Databases, 358\u2013369, 2002, Elsevier", - "DOI": "10.1016/B978-155860869-6/50039-1" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1145/1081870.1081966" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1109/tnsre.2013.2260561" - }, - { - "key": "ref10", - "unstructured": "Automated time series segmentation for human motion analysis, Bouchard, Durell, Center for Human Modeling and Simulation, University of Pennsylvania, 2006, Citeseer" - }, - { - "key": "ref11", - "doi-asserted-by": "publisher", - "DOI": "10.1109/hic.2016.7797709" - }, - { - "key": "ref12", - "doi-asserted-by": "publisher", - "DOI": "10.1371/journal.pone.0211466" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02404.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ], - "date-time": "2020-08-21T10:36:13Z", - "timestamp": 1598006173000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02404" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ] - }, - "references-count": 12, - "journal-issue": { - "issue": "52", - "published-online": { - "date-parts": [ - [ - 2020, - 8 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02404" - ], - "URL": "http://dx.doi.org/10.21105/joss.02404", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3979649\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2404", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 8, - 21 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 3, - 30 - ] - ], - "date-time": "2022-03-30T05:18:58Z", - "timestamp": 1648617538538 - }, - "reference-count": 7, - "publisher": "The Open Journal", - "issue": "47", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ], - "date-time": "2020-03-20T00:00:00Z", - "timestamp": 1584662400000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ], - "date-time": "2020-03-20T00:00:00Z", - "timestamp": 1584662400000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ], - "date-time": "2020-03-20T00:00:00Z", - "timestamp": 1584662400000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ] - }, - "DOI": "10.21105/joss.02074", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ], - "date-time": "2020-03-20T11:18:11Z", - "timestamp": 1584703091000 - }, - "page": "2074", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": [ - "pyGOURGS - global optimization of n-ary tree representable problems using uniform random global search" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-3050-8943", - "authenticated-orcid": false, - "given": "Sohrab", - "family": "Towfighi", - "sequence": "first", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1109/4235.585893" - }, - { - "key": "ref2", - "unstructured": "Tychonievich, Luther, Luther\u2019s Meanderings, symbolic regression, Enumerating Trees, https://www.cs.virginia.edu/\u00a0lat7h/blog/posts/434.html, 2019-06-14, 2013" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1186/s13040-018-0164-x" - }, - { - "key": "ref4", - "unstructured": "DEAP: Evolutionary algorithms made easy, Fortin, F\u00e9lix-Antoine and Rainville, Fran\u00e7ois-Michel De and Gardner, Marc-Andr\u00e9 and Parizeau, Marc and Gagn\u00e9, Christian, Journal of Machine Learning Research, 13, Jul, 2171\u20132175, 2012" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1287/moor.6.1.19" - }, - { - "key": "ref6", - "unstructured": "Langdon, W. B. and Poli, R., Why Ants are Hard, Proceedings of the Third Annual Conference on Genetic Programming (GP98), 1998, Koza, John R. and Banzhaf, Wolfgang and Chellapilla, Kumar and Deb, Kalyanmoy and Dorigo, Marco and Fogel, David B. and Garzon, Max H. and Goldberg, David E. and Iba, Hitoshi and Riolo, Rick, 193\u2013201, University of Wisconsin, Madison, Wisconsin, USA, San Francisco, CA, USA, Morgan Kaufmann, http://www.cs.ucl.ac.uk/staff/W.Langdon/ftp/papers/WBL.antspace_gp98.pdf" - }, - { - "key": "ref7", - "doi-asserted-by": "publisher", - "DOI": "10.21105/joss.01675" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02074/10.21105.joss.02074.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ], - "date-time": "2020-03-20T11:18:14Z", - "timestamp": 1584703094000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02074" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ] - }, - "references-count": 7, - "journal-issue": { - "issue": "47", - "published-online": { - "date-parts": [ - [ - 2020, - 3 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02074" - ], - "URL": "http://dx.doi.org/10.21105/joss.02074", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3710475\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2074", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 3, - 20 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2024, - 8, - 6 - ] - ], - "date-time": "2024-08-06T08:34:16Z", - "timestamp": 1722933256514 - }, - "reference-count": 17, - "publisher": "The Open Journal", - "issue": "52", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ], - "date-time": "2020-08-24T00:00:00Z", - "timestamp": 1598227200000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ], - "date-time": "2020-08-24T00:00:00Z", - "timestamp": 1598227200000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ], - "date-time": "2020-08-24T00:00:00Z", - "timestamp": 1598227200000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ] - }, - "DOI": "10.21105/joss.02313", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ], - "date-time": "2020-08-24T14:28:12Z", - "timestamp": 1598279292000 - }, - "page": "2313", - "source": "Crossref", - "is-referenced-by-count": 2, - "title": [ - "DORiE: A Discontinuous Galerkin Solver for Soil Water\nFlow and Passive Solute Transport Based on DUNE" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-4667-3652", - "authenticated-orcid": false, - "given": "Lukas", - "family": "Riedel", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-0814-9670", - "authenticated-orcid": false, - "given": "Santiago Ospina De Los", - "family": "R\u00edos", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-4465-7317", - "authenticated-orcid": false, - "given": "Dion", - "family": "H\u00e4fner", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-3295-7347", - "authenticated-orcid": false, - "given": "Ole", - "family": "Klein", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "issue": "4", - "key": "ern_posteriori_2008", - "article-title": "A posteriori energy-norm error estimates for\nadvection-diffusion equations approximated by weighted interior penalty\nmethods", - "volume": "26", - "author": "Ern", - "year": "2008", - "unstructured": "Ern, A., & Stephansen, A. F.\n(2008). A posteriori energy-norm error estimates for advection-diffusion\nequations approximated by weighted interior penalty methods. Journal of\nComputational Mathematics, 26(4), 488\u2013510.\nhttps://www.jstor.org/stable/43693458", - "journal-title": "Journal of Computational\nMathematics" - }, - { - "key": "ern_discontinuous_2009", - "doi-asserted-by": "publisher", - "DOI": "10.1093/imanum/drm050", - "article-title": "A discontinuous Galerkin method with weighted\naverages for advection\u2013diffusion equations with locally small and\nanisotropic diffusivity", - "volume": "29", - "author": "Ern", - "year": "2009", - "unstructured": "Ern, A., Stephansen, A. F., &\nZunino, P. (2009). A discontinuous Galerkin method with weighted\naverages for advection\u2013diffusion equations with locally small and\nanisotropic diffusivity. IMA Journal of Numerical Analysis, 29, 235\u2013256.\nhttps://doi.org/10.1093/imanum/drm050", - "journal-title": "IMA Journal of Numerical\nAnalysis" - }, - { - "key": "miller_numerical_2013", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.advwatres.2012.05.008", - "article-title": "Numerical simulation of water resources\nproblems: Models, methods, and trends", - "volume": "51", - "author": "Miller", - "year": "2013", - "unstructured": "Miller, C. T., Dawson, C. N.,\nFarthing, M. W., Hou, T. Y., Huang, J., Kees, C. E., Kelley, C. T.,\n& Langtangen, H. P. (2013). Numerical simulation of water resources\nproblems: Models, methods, and trends. Advances in Water Resources, 51,\n405\u2013437.\nhttps://doi.org/10.1016/j.advwatres.2012.05.008", - "journal-title": "Advances in Water Resources" - }, - { - "key": "schroeder_visualization_2006", - "isbn-type": "print", - "volume-title": "The Visualization Toolkit", - "author": "Schroeder", - "year": "2006", - "unstructured": "Schroeder, W., Martin, K., &\nLorensen, B. (2006). The Visualization Toolkit (A. Squillacote, Ed.; 4th\ned.). Kitware, Inc. ISBN:\u00a0978-1-930934-19-1", - "ISBN": "http://id.crossref.org/isbn/9781930934191" - }, - { - "issue": "2", - "key": "bastian_generic_2010", - "article-title": "Generic implementation of finite element\nmethods in the Distributed and Unified Numerics Environment\n(DUNE)", - "volume": "46", - "author": "Bastian", - "year": "2010", - "unstructured": "Bastian, P., Heimann, F., &\nMarnach, S. (2010). Generic implementation of finite element methods in\nthe Distributed and Unified Numerics Environment (DUNE). Kybernetika,\n46(2), 294\u2013315. dml.cz/dmlcz/140745", - "journal-title": "Kybernetika" - }, - { - "issue": "100", - "key": "blatt_distributed_2016", - "doi-asserted-by": "publisher", - "DOI": "10.11588/ans.2016.100.26526", - "article-title": "The Distributed and Unified Numerics\nEnvironment, Version 2.4", - "volume": "4", - "author": "Blatt", - "year": "2016", - "unstructured": "Blatt, M., Burchardt, A., Dedner, A.,\nEngwer, C., Fahlke, J., Flemisch, B., Gersbacher, C., Gr\u00e4ser, C.,\nGruber, F., Gr\u00fcninger, C., Kempf, D., Kl\u00f6fkorn, R., Malkmus, T.,\nM\u00fcthing, S., Nolte, M., Piatkowski, M., & Sander, O. (2016). The\nDistributed and Unified Numerics Environment, Version 2.4. Archive of\nNumerical Software, 4(100), 13\u201329.\nhttps://doi.org/10.11588/ans.2016.100.26526", - "journal-title": "Archive of Numerical Software" - }, - { - "key": "di_pietro_mathematical_2012", - "doi-asserted-by": "publisher", - "DOI": "10.1007/978-3-642-22980-0", - "volume-title": "Mathematical Aspects of Disconinuous Galerkin\nMethods", - "author": "Di Pietro", - "year": "2012", - "unstructured": "Di Pietro, D. A., & Ern, A.\n(2012). Mathematical Aspects of Disconinuous Galerkin Methods (G.\nAllaire & J. Garnier, Eds.). Springer.\nhttps://doi.org/10.1007/978-3-642-22980-0" - }, - { - "issue": "5", - "key": "bastian_fully-coupled_2014", - "doi-asserted-by": "publisher", - "DOI": "10.1007/s10596-014-9426-y", - "article-title": "A fully-coupled discontinuous Galerkin method\nfor two-phase flow in porous media with discontinuous capillary\npressure", - "volume": "18", - "author": "Bastian", - "year": "2014", - "unstructured": "Bastian, P. (2014). A fully-coupled\ndiscontinuous Galerkin method for two-phase flow in porous media with\ndiscontinuous capillary pressure. Computational Geosciences, 18(5),\n779\u2013796.\nhttps://doi.org/10.1007/s10596-014-9426-y", - "journal-title": "Computational Geosciences", - "ISSN": "http://id.crossref.org/issn/1573-1499", - "issn-type": "print" - }, - { - "issue": "12", - "key": "ern_accurate_2007", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.crma.2007.10.036", - "article-title": "An accurate H(div) flux reconstruction for\ndiscontinuous Galerkin approximations of elliptic\nproblems", - "volume": "345", - "author": "Ern", - "year": "2007", - "unstructured": "Ern, A., Nicaise, S., & Vohral\u00edk,\nM. (2007). An accurate H(div) flux reconstruction for discontinuous\nGalerkin approximations of elliptic problems. Comptes Rendus\nMathematique, 345(12), 709\u2013712.\nhttps://doi.org/10.1016/j.crma.2007.10.036", - "journal-title": "Comptes Rendus Mathematique", - "ISSN": "http://id.crossref.org/issn/1631-073X", - "issn-type": "print" - }, - { - "issue": "11", - "key": "geuzaine_gmsh_2009", - "doi-asserted-by": "publisher", - "DOI": "10.1002/nme.2579", - "article-title": "Gmsh: A 3-D finite element mesh generator\nwith built-in pre- and post-processing facilities", - "volume": "79", - "author": "Geuzaine", - "year": "2009", - "unstructured": "Geuzaine, C., & Remacle, J.-F.\n(2009). Gmsh: A 3-D finite element mesh generator with built-in pre- and\npost-processing facilities. International Journal for Numerical Methods\nin Engineering, 79(11), 1309\u20131331.\nhttps://doi.org/10.1002/nme.2579", - "journal-title": "International Journal for Numerical Methods\nin Engineering", - "ISSN": "http://id.crossref.org/issn/1097-0207", - "issn-type": "print" - }, - { - "key": "the_hdf_group_hierarchical_1997", - "article-title": "Hierarchical Data Format, Version\n5", - "author": "The HDF Group", - "year": "1997", - "unstructured": "The HDF Group. (1997). Hierarchical\nData Format, Version 5.\nhttp://www.hdfgroup.org/HDF5/" - }, - { - "issue": "1", - "key": "vogel_scale_2019", - "doi-asserted-by": "publisher", - "DOI": "10.2136/vzj2019.01.0001", - "article-title": "Scale issues in soil\nhydrology", - "volume": "18", - "author": "Vogel", - "year": "2019", - "unstructured": "Vogel, H.-J. (2019). Scale issues in\nsoil hydrology. Vadose Zone Journal, 18(1).\nhttps://doi.org/10.2136/vzj2019.01.0001", - "journal-title": "Vadose Zone Journal", - "ISSN": "http://id.crossref.org/issn/1539-1663", - "issn-type": "print" - }, - { - "key": "ole_klein_dune_2020", - "article-title": "DUNE Randomfield", - "author": "Klein", - "year": "2016", - "unstructured": "Klein, O. (2016). DUNE Randomfield\n[{GitLab} {Repository}].\nhttps://gitlab.dune-project.org/oklein/dune-randomfield" - }, - { - "key": "hannes_h_bauser_challenges_2020", - "doi-asserted-by": "publisher", - "DOI": "10.1002/vzj2.20040", - "article-title": "Challenges with effective representations of\nheterogeneity in soil hydrology based on local water content\nmeasurements", - "volume": "19", - "author": "Bauser", - "year": "2020", - "unstructured": "Bauser, H. H., Riedel, L., Berg, D.,\nTroch, P., & Roth, K. (2020). Challenges with effective\nrepresentations of heterogeneity in soil hydrology based on local water\ncontent measurements. Vadose Zone Journal, 19, e20040.\nhttps://doi.org/10.1002/vzj2.20040", - "journal-title": "Vadose Zone Journal" - }, - { - "issue": "9", - "key": "li_adaptive_2007", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.advwatres.2007.02.007", - "article-title": "Adaptive local discontinuous Galerkin\napproximation to Richards\u2019 equation", - "volume": "30", - "author": "Li", - "year": "2007", - "unstructured": "Li, H., Farthing, Matthew W., &\nMiller, C. T. (2007). Adaptive local discontinuous Galerkin\napproximation to Richards\u2019 equation. Advances in Water Resources, 30(9),\n1883\u20131901.\nhttps://doi.org/10.1016/j.advwatres.2007.02.007", - "journal-title": "Advances in Water Resources" - }, - { - "issue": "6", - "key": "farthing_numerical_2017", - "doi-asserted-by": "publisher", - "DOI": "10.2136/sssaj2017.02.0058", - "article-title": "Numerical solution of Richards\u2019 equation: A\nreview of advances and challenges", - "volume": "81", - "author": "Farthing", - "year": "2017", - "unstructured": "Farthing, M. W., & Ogden, F. L.\n(2017). Numerical solution of Richards\u2019 equation: A review of advances\nand challenges. Soil Science Society of America Journal, 81(6),\n1257\u20131269.\nhttps://doi.org/10.2136/sssaj2017.02.0058", - "journal-title": "Soil Science Society of America\nJournal", - "ISSN": "http://id.crossref.org/issn/0361-5995", - "issn-type": "print" - }, - { - "issue": "9", - "key": "flemisch_dumux_2011", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.advwatres.2011.03.007", - "article-title": "DuMux: DUNE for\nmulti-{phase,component,scale,physics,\u2026} flow and transport in porous\nmedia", - "volume": "34", - "author": "Flemisch", - "year": "2011", - "unstructured": "Flemisch, B., Darcis, M.,\nErbertseder, K., Faigle, B., Lauser, A., Mosthaf, K., M\u00fcthing, S.,\nNuske, P., Tatomir, A., Wolff, M., & Helmig, R. (2011). DuMux: DUNE\nfor multi-{phase,component,scale,physics,\u2026} flow and transport in porous\nmedia. Advances in Water Resources, 34(9), 1102\u20131112.\nhttps://doi.org/10.1016/j.advwatres.2011.03.007", - "journal-title": "Advances in Water Resources" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02313.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2022, - 8, - 25 - ] - ], - "date-time": "2022-08-25T16:51:48Z", - "timestamp": 1661446308000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02313" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ] - }, - "references-count": 17, - "journal-issue": { - "issue": "52", - "published-online": { - "date-parts": [ - [ - 2020, - 8 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02313" - ], - "URL": "http://dx.doi.org/10.21105/joss.02313", - "relation": { - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2313", - "asserted-by": "subject" - } - ], - "references": [ - { - "id-type": "doi", - "id": "10.5281/zenodo.3997152", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 8, - 24 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 4, - 1 - ] - ], - "date-time": "2022-04-01T20:55:25Z", - "timestamp": 1648846525658 - }, - "reference-count": 21, - "publisher": "The Open Journal", - "issue": "56", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ], - "date-time": "2020-12-03T00:00:00Z", - "timestamp": 1606953600000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ], - "date-time": "2020-12-03T00:00:00Z", - "timestamp": 1606953600000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ], - "date-time": "2020-12-03T00:00:00Z", - "timestamp": 1606953600000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ] - }, - "DOI": "10.21105/joss.02444", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ], - "date-time": "2020-12-03T22:28:58Z", - "timestamp": 1607034538000 - }, - "page": "2444", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": [ - "TBFMM: A C++ generic and parallel fast multipole method library" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0003-0281-9709", - "authenticated-orcid": false, - "given": "Berenger", - "family": "Bramas", - "sequence": "first", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1016/0021-9991(87)90140-9" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1109/aps.1994.407723" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1109/tpds.2017.2697857" - }, - { - "key": "ref4", - "unstructured": "OpenMP Architecture Review Board, OpenMP Application Program Interface, jul, 2013, https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf, 7" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1155/2017/5482468" - }, - { - "key": "ref6", - "unstructured": "Task-based fast multipole method for clusters of multicore processors, Agullo, Emmanuel and Bramas, B\u00e9renger and Coulaud, Olivier and Khannouz, Martin and Stanisic, Luka, https://hal.inria.fr/hal-01387482, Research Report, RR-8970, 15 , Inria Bordeaux Sud-Ouest, 2017, mar, multicore processor ; high performance computing (HPC) ; fast multipole method ; hybrid parallelization ; runtime system ; task-based programming ; cluster ; FMM ; m\u00e9thode multip\u00f4les rapide ; Calcul haute performance ; architecture multic; moteur d\u2019ex\u00e9cution ; parall\u00e9lisation hybride ; programmation \u00e0 base de t\u00e2ches ; MPI ; OpenMP, https://hal.inria.fr/hal-01387482/file/report-8970.pdf, hal-01387482, v4, 3" - }, - { - "key": "ref7", - "unstructured": "Optimization and parallelization of the boundary element method for the wave equation in time domain, Bramas, B\u00e9renger, 2016, Bordeaux" - }, - { - "key": "ref8", - "unstructured": "The best of the 20th century: Editors name top 10 algorithms, Cipra, Barry A, SIAM news, 33, 4, 1\u20132, 2000" - }, - { - "key": "ref9", - "unstructured": "Fast hierarchical algorithms for generating Gaussian random fields, Blanchard, Pierre and Coulaud, Olivier and Darve, Eric, https://hal.inria.fr/hal-01228519, Research Report, Inria Bordeaux Sud-Ouest, 2015, nov, H 2 -methods ; FMM ; FFT ; randomized SVD ; covariance kernel matrices ; multivariate Gaussian random variables, https://hal.inria.fr/hal-01228519v1/file/RR-8811.pdf, hal-01228519, v1, 11" - }, - { - "key": "ref10", - "unstructured": "An Efficient Interpolation Based FMM for Dislocation Dynamics Simulations, Blanchard, Pierre and Coulaud, Olivier and Etcheverry, Arnaud and Dupuy, Laurent and Darve, Eric, https://hal.archives-ouvertes.fr/hal-01334842, Platform for Advanced Scientific Computing, Lausanne, Switzerland, USI and CSCS and EPFL, 2016, jun, hal-01334842, v1, 6" - }, - { - "key": "ref11", - "unstructured": "Optimizing the Black-box FMM for Smooth and Oscillatory Kernels, Darve, Eric and Messner, Matthias and Schanz, Martin and Coulaud, Olivier, https://hal.inria.fr/hal-00799885, SIAM Conference on Computational Science and Engineering (SIAM CSE 2013), Boston, United States, 2013, feb, optimisation ; Fast multipole method ; symmetry ; BLAS, hal-00799885, v1, 2" - }, - { - "key": "ref12", - "doi-asserted-by": "crossref", - "unstructured": "A fast multipole method for Maxwell equations stable at all frequencies, Darve, Eric and Hav\u00e9, Pascal, Philosophical Transactions of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 362, 1816, 603\u2013628, 2004, The Royal Society", - "DOI": "10.1098/rsta.2003.1337" - }, - { - "key": "ref13", - "doi-asserted-by": "publisher", - "DOI": "10.4208/cicp.020215.150515sw" - }, - { - "key": "ref14", - "unstructured": "ExaFMM: An open source library for Fast Multipole Methods aimed towards Exascale systems, Barba, L and Yokota, Rio, Boston: Boston University. Retrieved from barbagroup: http://barbagroup. bu. edu, 2011" - }, - { - "key": "ref15", - "unstructured": "Coupled Fast Multipole Method-Finite Element Method for the analysis of magneto-mechanical problems, Frangi, Attilio and Faure-Ragani, Paolo and Ghezzi, Luca, Proceedings of the Sixth French National Congress\" Calcul des structures, 273\u2013280, 2003" - }, - { - "key": "ref16", - "unstructured": "The fast multipole method for electromagnetic field computation in numerical and physical hybrid systems, Vazquez Sabariego, Ruth, 2004, Universit\u00e9 de Li\u00e8ge" - }, - { - "key": "ref17", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.enganabound.2012.07.004" - }, - { - "key": "ref18", - "unstructured": "Hierarchical Randomized Low-Rank Approximations, Blanchard, Pierre and Coulaud, Olivier and Darve, E and Bramas, B, https://hal.archives-ouvertes.fr/hal-01255724, SIAM Conference on Applied Linear Algebra (SIAM LA), Atlanta, United States, SIAM, 2015, oct, hal-01255724, v1, 10" - }, - { - "key": "ref19", - "unstructured": "Implementation of rotation-based operators for fast multipole method in X10, Haigh, Andrew, 2011, Austrailian National University" - }, - { - "key": "ref20", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.cam.2003.12.011" - }, - { - "key": "ref21", - "doi-asserted-by": "publisher", - "DOI": "10.1145/1654059.1654118" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02444.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ], - "date-time": "2020-12-03T22:29:56Z", - "timestamp": 1607034596000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02444" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ] - }, - "references-count": 21, - "journal-issue": { - "issue": "56", - "published-online": { - "date-parts": [ - [ - 2020, - 12 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02444" - ], - "URL": "http://dx.doi.org/10.21105/joss.02444", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4302384\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2444", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 12, - 3 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 4, - 5 - ] - ], - "date-time": "2022-04-05T14:45:48Z", - "timestamp": 1649169948811 - }, - "reference-count": 4, - "publisher": "The Open Journal", - "issue": "56", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ], - "date-time": "2020-12-14T00:00:00Z", - "timestamp": 1607904000000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ], - "date-time": "2020-12-14T00:00:00Z", - "timestamp": 1607904000000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ], - "date-time": "2020-12-14T00:00:00Z", - "timestamp": 1607904000000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ] - }, - "DOI": "10.21105/joss.02695", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ], - "date-time": "2020-12-14T12:30:34Z", - "timestamp": 1607949034000 - }, - "page": "2695", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": [ - "Multiscale Solar Water Heating" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "given": "Milica", - "family": "Grahovac", - "sequence": "first", - "affiliation": [] - }, - { - "given": "Katie", - "family": "Coughlin", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Hannes", - "family": "Gerhart", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Robert", - "family": "Hosbach", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "unstructured": "Costs and Benefits of Community versus Individual End-use Infrastructure for Solar Water Heating, Lawrence Berkeley National Laboratory, Coughlin, Katie and Grahovac, Milica and Ganeshalingam, Mohan and Hosbach, Robert and Vossos, Vagelis, 2021, California Energy Commission" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.11578/dc.20190524.2" - }, - { - "key": "ref3", - "unstructured": "Implementation of a Flexible Web Framework for Simulating Python System Models, en, Gerhart, Hannes, 82, 2019, Technical University of Munich, Technical University of Munich" - }, - { - "key": "ref4", - "unstructured": "Costs and Benefits of Community Scale Solar Water Heating, en, Grahovac, Milica and Coughlin, Katie and Ganeshalingam, Mohan and Hosbach, Robert and Vossos, Vagelis, 16, In Proceedings of ACEEE Summer Study 2020, 2020, https://aceee2020.conferencespot.org/event-data/pdf/catalyst_activity_10923/catalyst_activity_paper_20200812133157248_498ce455_3a9c_4278_9088_6e3fdce5745b" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02695.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ], - "date-time": "2020-12-14T12:30:35Z", - "timestamp": 1607949035000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02695" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ] - }, - "references-count": 4, - "journal-issue": { - "issue": "56", - "published-online": { - "date-parts": [ - [ - 2020, - 12 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02695" - ], - "URL": "http://dx.doi.org/10.21105/joss.02695", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4305504\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2695", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 12, - 14 - ] - ] - } - }, - { - "indexed": { - "date-parts": [ - [ - 2023, - 10, - 31 - ] - ], - "date-time": "2023-10-31T18:14:43Z", - "timestamp": 1698776083707 - }, - "reference-count": 11, - "publisher": "The Open Journal", - "issue": "54", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ], - "date-time": "2020-10-29T00:00:00Z", - "timestamp": 1603929600000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ], - "date-time": "2020-10-29T00:00:00Z", - "timestamp": 1603929600000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ], - "date-time": "2020-10-29T00:00:00Z", - "timestamp": 1603929600000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" - ], - "published-print": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ] - }, - "DOI": "10.21105/joss.02580", - "type": "journal-article", - "created": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ], - "date-time": "2020-10-29T06:57:11Z", - "timestamp": 1603954631000 - }, - "page": "2580", - "source": "Crossref", - "is-referenced-by-count": 1, - "title": [ - "Open Source Optical Coherence Tomography Software" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0002-4494-6127", - "authenticated-orcid": false, - "given": "Miroslav", - "family": "Zabic", - "sequence": "first", - "affiliation": [] - }, - { - "given": "Ben", - "family": "Matthias", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Alexander", - "family": "Heisterkamp", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Tammo", - "family": "Ripken", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1364/boe.3.003067" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1364/oe.18.011772" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1117/1.3548153" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1117/1.JBO.17.10.100502" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1109/fccm.2011.27" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1117/1.JBO.18.2.026002" - }, - { - "key": "ref7", - "doi-asserted-by": "publisher", - "DOI": "10.1364/OE.18.024395" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1364/BOE.5.002963" - }, - { - "key": "ref9", - "unstructured": "GPU-accelerated single-pass raycaster, \u200bPilia, Martino, \u200bGitHub repository, 2018, \u200bGitHub, https://github.com/m-pilia/volume-raycasting" - }, - { - "key": "ref10", - "unstructured": "Qt, 2020, https://www.qt.io, 2020-08-23" - }, - { - "key": "ref11", - "unstructured": "CUDA, \u200bNVIDIA, 2020, https://developer.nvidia.com/cuda-zone, 2020-08-23" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02580.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ], - "date-time": "2020-10-29T06:57:17Z", - "timestamp": 1603954637000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02580" - } - }, - "issued": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] - ] - }, - "references-count": 11, - "journal-issue": { - "issue": "54", - "published-online": { - "date-parts": [ - [ - 2020, - 10 - ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02580" - ], - "URL": "http://dx.doi.org/10.21105/joss.02580", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4148992\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2580", - "asserted-by": "subject" - } - ] - }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { - "date-parts": [ - [ - 2020, - 10, - 29 - ] + { + "indexed": { + "date-parts": [ + [ + "twentytwentytwo", + "three", + 28 ] - } + ], + "date-time": "2022-03-28T23:34:11Z", + "timestamp": 1648510451692 }, - { - "indexed": { - "date-parts": [ - [ - 2023, - 8, - 28 - ] - ], - "date-time": "2023-08-28T17:23:59Z", - "timestamp": 1693243439260 + "reference-count": 28, + "publisher": "The Open Journal", + "issue": "53", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] + ], + "date-time": "2020-09-26T00:00:00Z", + "timestamp": 1601078400000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "reference-count": 10, - "publisher": "The Open Journal", - "issue": "55", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] - ], - "date-time": "2020-11-20T00:00:00Z", - "timestamp": 1605830400000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] + ], + "date-time": "2020-09-26T00:00:00Z", + "timestamp": 1601078400000 }, - { - "start": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] - ], - "date-time": "2020-11-20T00:00:00Z", - "timestamp": 1605830400000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] + ], + "date-time": "2020-09-26T00:00:00Z", + "timestamp": 1601078400000 }, - { - "start": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] - ], - "date-time": "2020-11-20T00:00:00Z", - "timestamp": 1605830400000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] + ] + }, + "DOI": "10.21105/joss.02583", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] ], - "content-domain": { - "domain": [], - "crossmark-restriction": false - }, - "short-container-title": [ - "JOSS" + "date-time": "2020-09-26T12:21:07Z", + "timestamp": 1601122867000 + }, + "page": "2583", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": "emba: R package for analysis and visualization of biomarkers in boolean model ensembles", + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-3609-8674", + "authenticated-orcid": false, + "given": "John", + "family": "Zobolas", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-1171-9876", + "authenticated-orcid": false, + "given": "Martin", + "family": "Kuiper", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-3357-425X", + "authenticated-orcid": false, + "given": "\u00c5smund", + "family": "Flobak", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fgene.2016.00094" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1038/ncb1497" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1038/nbt.2284" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1186/s12859-016-1287-z" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1158/0008-5472.CAN-17-0078" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1371/journal.pcbi.1004426" + }, + { + "key": "ref7", + "doi-asserted-by": "publisher", + "DOI": "10.1016/J.CELS.2018.10.013" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1186/1752-0509-6-96" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btw682" + }, + { + "key": "ref10", + "doi-asserted-by": "publisher", + "DOI": "10.1038/nmeth.2016" + }, + { + "key": "ref11", + "doi-asserted-by": "publisher", + "DOI": "10.1021/bi902202q" + }, + { + "key": "ref12", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btq124" + }, + { + "key": "ref13", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fphys.2018.01605" + }, + { + "key": "ref14", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fphys.2018.00646" + }, + { + "key": "ref15", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fphys.2018.00680" + }, + { + "key": "ref16", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btv013" + }, + { + "key": "ref17", + "doi-asserted-by": "publisher", + "DOI": "10.1007/978-3-319-67471-1_20" + }, + { + "key": "ref18", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.molmed.2017.08.003" + }, + { + "key": "ref19", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btx123" + }, + { + "key": "ref20", + "doi-asserted-by": "publisher", + "DOI": "10.1186/1752-0509-6-133" + }, + { + "key": "ref21", + "doi-asserted-by": "publisher", + "DOI": "10.1002/psp4.12225" + }, + { + "key": "ref22", + "doi-asserted-by": "publisher", + "DOI": "10.1088/1478-3975/9/5/055001" + }, + { + "key": "ref23", + "doi-asserted-by": "publisher", + "DOI": "10.1186/s12864-019-6413-7" + }, + { + "key": "ref24", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btaa561" + }, + { + "key": "ref25", + "unstructured": "usefun: A Collection of Useful Functions by John, Zobolas, John, R package version 0.4.7, https://github.com/bblodfon/usefun, 2020" + }, + { + "key": "ref26", + "unstructured": "Zobolas, John, Ensemble boolean model analyses related to drug prediction performance, 2020, GitHub, https://github.com/bblodfon/gitsbe-model-analysis" + }, + { + "key": "ref27", + "unstructured": "Zobolas, John, DrugLogics software documentation, 2020, GitHub Pages, https://druglogics.github.io/druglogics-doc/" + }, + { + "key": "ref28", + "unstructured": "Zobolas, John, emba package website, 2020, GitHub Pages, https://bblodfon.github.io/emba/" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02583.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 9, + 26 + ] ], - "published-print": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] + "date-time": "2020-09-26T12:21:12Z", + "timestamp": 1601122872000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02583" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 9, + 26 ] - }, - "DOI": "10.21105/joss.02483", - "type": "journal-article", - "created": { + ] + }, + "references-count": 28, + "journal-issue": { + "issue": "53", + "published-online": { "date-parts": [ [ 2020, - 11, - 20 + 9 ] - ], - "date-time": "2020-11-20T17:42:58Z", - "timestamp": 1605894178000 - }, - "page": "2483", - "source": "Crossref", - "is-referenced-by-count": 1, - "title": [ - "pyveg: A Python package for analysing the time evolution of patterned vegetation using Google Earth Engine" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "given": "Nick", - "family": "Barlow", - "sequence": "first", - "affiliation": [] - }, - { - "given": "Camila", - "family": "Smith", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Samuel", - "family": "Van Stroud", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Jesse", - "family": "Abrams", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Chris", - "family": "Boulton", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Joshua", - "family": "Buxton", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1098/rsos.160443" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1111/gcb.14059" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1073/pnas.0802430105" - }, - { - "key": "ref4", - "unstructured": "Euler\u2019s Gem: The Polyhedron Formula and the Birth of Topology, Richeson, D.S., 9780691154572, https://books.google.co.uk/books?id=0m8-zQEACAAJ, 2012, Princeton University Press" - }, - { - "key": "ref5", - "unstructured": "2020, Principe, R.E. et al, https://github.com/gee-community/gee_tools" - }, - { - "key": "ref6", - "unstructured": "Bury, Thomas, 2020, https://github.com/ThomasMBury/ewstools" - }, - { - "key": "ref7", - "unstructured": "ECMWF, 2020, Copernicus Climate Change Service (C3S): ERA5: Fifth generation of ECMWF atmospheric reanalyses of the global climate." - }, - { - "key": "ref8", - "unstructured": "ESA, 2020, Contains modified Copernicus Sentinel data, courtesy of ESA" - }, - { - "key": "ref9", - "unstructured": "USGS, 2020, Landsat-4, Landsat-5, Landsat-7, Landsat-8 data courtesy of the U.S. Geological Survey" - }, - { - "key": "ref10", - "unstructured": "Skwarnicki, Tomasz, A study of the radiative CASCADE transitions between the Upsilon-Prime and Upsilon resonances, PhD thesis, Cracow, INP, 1986" + ] + } + }, + "alternative-id": [ + "10.21105/joss.02583" + ], + "URL": "http://dx.doi.org/10.21105/joss.02583", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4043085\u201d", + "asserted-by": "subject" } ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ + "has-review": [ { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02483.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] - ], - "date-time": "2020-11-20T17:43:31Z", - "timestamp": 1605894211000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02483" + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2583", + "asserted-by": "subject" } - }, - "issued": { - "date-parts": [ - [ - 2020, - 11, - 20 - ] + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + "twentytwentytwo", + "three", + 28 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2023, + 5, + 19 ] + ], + "date-time": "2023-05-19T09:31:24Z", + "timestamp": 1684488684122 + }, + "reference-count": 12, + "publisher": "The Open Journal", + "issue": "46", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 2, + 10 + ] + ], + "date-time": "2020-02-10T00:00:00Z", + "timestamp": 1581292800000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "references-count": 10, - "journal-issue": { - "issue": "55", - "published-online": { + { + "start": { "date-parts": [ [ 2020, - 11 + 2, + 10 ] - ] - } + ], + "date-time": "2020-02-10T00:00:00Z", + "timestamp": 1581292800000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "alternative-id": [ - "10.21105/joss.02483" - ], - "URL": "http://dx.doi.org/10.21105/joss.02483", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.4281273\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2483", - "asserted-by": "subject" - } + { + "start": { + "date-parts": [ + [ + 2020, + 2, + 10 + ] + ], + "date-time": "2020-02-10T00:00:00Z", + "timestamp": 1581292800000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + 2020, + 2, + "ten" + ] + }, + "DOI": "10.21105/joss.02013", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 2, + 10 ] - }, - "ISSN": [ - "2475-9066" ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } + "date-time": "2020-02-10T18:47:10Z", + "timestamp": 1581360430000 + }, + "page": "2013", + "source": "Crossref", + "is-referenced-by-count": 6, + "title": [ + "thresholdmodeling: A Python package for modeling excesses over a threshold using the Peak-Over-Threshold Method and the Generalized Pareto Distribution" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-5829-7711", + "authenticated-orcid": false, + "given": "Iago", + "family": "Lemos", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-0170-6083", + "authenticated-orcid": false, + "given": "Ant\u00f4nio", + "family": "Lima", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-8166-5666", + "authenticated-orcid": false, + "given": "Marcus", + "family": "Duarte", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1007/978-1-4471-3675-0" + }, + { + "key": "ref2", + "unstructured": ": Generalized Pareto Distribution and Peaks Over Threshold, Ribatet, Mathieu and Dutang, Christophe, 2019, package version 1.1-7, https://cran.r-project.org/web/packages/POT/index.html" + }, + { + "key": "ref3", + "unstructured": ": Extreme Value Analysis, Gilleland, Eric, 2019, package version 2.0-11, https://cran.r-project.org/web/packages/extRemes/index.html" + }, + { + "key": "ref4", + "unstructured": ": Functions for Extreme Value Distributions, Stephenson, Alec, 2018, package version 2.3-3, https://cran.r-project.org/web/packages/evd/index.html" + }, + { + "key": "ref5", + "unstructured": "Tan, Hwei-Yang, Analysis of Corrosion Data for Integrity Assessments, Thesis for the Degree of Doctor of Philosophy, 2017, Brunel University London, 2017" + }, + { + "key": "ref6", + "unstructured": "Bommier, Esther, Peaks-Over-Threshold Modelling of Environmental Data, Examensarbete i matematik, Uppsala University, 2014" + }, + { + "key": "ref7", + "unstructured": "Rydman, Max, Application of the Peaks-Over-Threshold Method on Insurance Data, Examensarbete i matematik, Uppsala University, 2018" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1016/S0309-1708(02)00056-8" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1017/CBO9780511529443" + }, + { + "key": "ref10", + "doi-asserted-by": "publisher", + "DOI": "10.6028/jres.099.028" + }, + { + "key": "ref11", + "unstructured": "Scipy, scipy.stats.genpareto, 2019, https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.genpareto.html" + }, + { + "key": "ref12", + "unstructured": "Correoso, Kiko, scikit-extremes, 2019, https://github.com/kikocorreoso/scikit-extremes" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.02013/10.21105.joss.02013.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 2, + 10 + ] ], - "published": { + "date-time": "2020-02-10T18:47:15Z", + "timestamp": 1581360435000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02013" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 2, + 10 + ] + ] + }, + "references-count": 12, + "journal-issue": { + "issue": "46", + "published-online": { "date-parts": [ [ 2020, - 11, - 20 + 2 ] ] } }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 4, - 6 - ] - ], - "date-time": "2022-04-06T02:25:07Z", - "timestamp": 1649211907396 - }, - "reference-count": 9, - "publisher": "The Open Journal", - "issue": "51", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 7, - 5 - ] - ], - "date-time": "2020-07-05T00:00:00Z", - "timestamp": 1593907200000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 7, - 5 - ] - ], - "date-time": "2020-07-05T00:00:00Z", - "timestamp": 1593907200000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, + "alternative-id": [ + "10.21105/joss.02013" + ], + "URL": "http://dx.doi.org/10.21105/joss.02013", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3661338\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ { - "start": { - "date-parts": [ - [ - 2020, - 7, - 5 - ] - ], - "date-time": "2020-07-05T00:00:00Z", - "timestamp": 1593907200000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2013", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + 2020 + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2024, + 3, + 18 + ] ], - "content-domain": { - "domain": [], - "crossmark-restriction": false + "date-time": "2024-03-18T11:29:06Z", + "timestamp": 1710761346762 + }, + "reference-count": 31, + "publisher": "The Open Journal", + "issue": "51", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] + ], + "date-time": "2020-07-04T00:00:00Z", + "timestamp": 1593820800000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "short-container-title": [ - "JOSS" + { + "start": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] + ], + "date-time": "2020-07-04T00:00:00Z", + "timestamp": 1593820800000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] + ], + "date-time": "2020-07-04T00:00:00Z", + "timestamp": 1593820800000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + "7x", + "4x" + ] + ] + }, + "DOI": "10.21105/joss.01906", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] ], - "published-print": { - "date-parts": [ - [ - 2020, - 7, - 5 - ] + "date-time": "2020-07-04T16:51:59Z", + "timestamp": 1593881519000 + }, + "page": "1906", + "source": "Crossref", + "is-referenced-by-count": 4, + "title": [ + "FLAM: Fast Linear Algebra in MATLAB - Algorithms for Hierarchical Matrices" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0001-5450-4966", + "authenticated-orcid": false, + "given": "Kenneth", + "family": "Ho", + "sequence": "first", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s10915-013-9714-z" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.21105/joss.01167" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s10444-020-09774-2" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.jcp.2016.12.051" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.jcp.2018.12.014" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1017/jfm.2017.150" + }, + { + "key": "ref7", + "doi-asserted-by": "publisher", + "DOI": "10.4310/CMS.2020.v18.n1.a4" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1137/15M1010117" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s11464-012-0188-3" + }, + { + "key": "ref10", + "doi-asserted-by": "publisher", + "DOI": "10.4208/cicp.150215.260615sw" + }, + { + "key": "ref11", + "doi-asserted-by": "publisher", + "DOI": "10.1016/0021-9991(87)90140-9" + }, + { + "key": "ref12", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s006070050015" + }, + { + "key": "ref13", + "doi-asserted-by": "publisher", + "DOI": "10.1137/120866683" + }, + { + "key": "ref14", + "doi-asserted-by": "publisher", + "DOI": "10.1137/120902677" + }, + { + "key": "ref15", + "doi-asserted-by": "publisher", + "DOI": "10.1002/cpa.21577" + }, + { + "key": "ref16", + "doi-asserted-by": "publisher", + "DOI": "10.1002/cpa.21582" + }, + { + "key": "ref17", + "doi-asserted-by": "publisher", + "DOI": "10.1137/16M1081920" + }, + { + "key": "ref18", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.enganabound.2019.06.020" + }, + { + "key": "ref19", + "doi-asserted-by": "publisher", + "DOI": "10.1186/s40687-017-0100-6" + }, + { + "key": "ref20", + "doi-asserted-by": "publisher", + "DOI": "10.1349/ddlp.2447" + }, + { + "key": "ref21", + "doi-asserted-by": "publisher", + "DOI": "10.1137/060662253" + }, + { + "key": "ref22", + "doi-asserted-by": "publisher", + "DOI": "10.1137/19M1288048" + }, + { + "key": "ref23", + "doi-asserted-by": "publisher", + "DOI": "10.1137/15M1024500" + }, + { + "key": "ref24", + "unstructured": "Minden, V. L., Data-sparse algorithms for structured matrices, Stanford University, 2017" + }, + { + "key": "ref25", + "doi-asserted-by": "publisher", + "DOI": "10.1137/16M1095949" + }, + { + "key": "ref26", + "doi-asserted-by": "publisher", + "DOI": "10.1137/17M1116477" + }, + { + "key": "ref27", + "doi-asserted-by": "publisher", + "DOI": "10.1145/2930660" + }, + { + "key": "ref28", + "doi-asserted-by": "publisher", + "DOI": "10.4310/CMS.2019.v17.n6.a7" + }, + { + "key": "ref29", + "unstructured": "Wang, S., Efficient high-order integral equation methods for the heat equation, New Jersey Institute of Technology, 2016" + }, + { + "key": "ref30", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s10915-018-0872-x" + }, + { + "key": "ref31", + "doi-asserted-by": "publisher", + "DOI": "10.1002/nla.691" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.01906/10.21105.joss.01906.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 7, + 4 ] - }, - "DOI": "10.21105/joss.02284", - "type": "journal-article", - "created": { + ], + "date-time": "2020-07-04T16:52:02Z", + "timestamp": 1593881522000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.01906" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] + ] + }, + "references-count": 31, + "journal-issue": { + "issue": "51", + "published-online": { "date-parts": [ [ 2020, - 7, - 5 + 7 ] - ], - "date-time": "2020-07-05T19:51:15Z", - "timestamp": 1593978675000 - }, - "page": "2284", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": [ - "GridTest: testing and metrics collection for Python" + ] + } + }, + "alternative-id": [ + "10.21105/joss.01906" + ], + "URL": "http://dx.doi.org/10.21105/joss.01906", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3930385\u201d", + "asserted-by": "subject" + } ], - "prefix": "10.21105", - "volume": "5", - "author": [ + "has-review": [ { - "ORCID": "http://orcid.org/0000-0002-4387-3819", - "authenticated-orcid": false, - "given": "Vanessa", - "family": "Sochat", - "sequence": "first", - "affiliation": [] + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/1906", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 7, + 4 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 3, + 29 + ] ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "unstructured": "GridTest on GitHub, GridTest, https://github.com/vsoch/gridtest, 2020, ://github.com/vsoch/gridtest/, Accessed: 2020-05-14" - }, - { - "key": "ref2", - "unstructured": "GridTest, GridTest Documentation, https://vsoch.github.io/gridtest/, 2020, ://vsoch.github.io/gridtest, Accessed: 2020-05-14" - }, - { - "key": "ref3", - "unstructured": "Scientific Software Testing: A Practical Example, Koteska, Bojana and Pejov, Ljupco and Mishev, Anastas, SQAMIA, 2015" - }, - { - "key": "ref4", - "unstructured": "sklearn.model_selection.ParameterGrid \u2014 scikit-learn 0.23.1 documentation, scikit-learn: machine learning in Python, ://scikit-learn.org/stable/modules/generated/sklearn.model_selection.ParameterGrid.html, Accessed: 2020-6-30, 2020" - }, - { - "key": "ref5", - "unstructured": "Scikit-learn: Machine Learning in Python, Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E., Journal of Machine Learning Research, 12, 2825\u20132830, 2011" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.1107/S2059798320003198" + "date-time": "2022-03-29T15:34:34Z", + "timestamp": 1648568074460 + }, + "reference-count": 14, + "publisher": "The Open Journal", + "issue": "53", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] + ], + "date-time": "2020-09-07T00:00:00Z", + "timestamp": 1599436800000 }, - { - "key": "ref7", - "unstructured": "Keras, Chollet, Francois and others, 2015, GitHub, https://github.com/fchollet/keras" + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] + ], + "date-time": "2020-09-07T00:00:00Z", + "timestamp": 1599436800000 }, - { - "key": "ref8", - "unstructured": "Grid (Hyperparameter) Search \u2014 H2O 3.30.0.5 documentation, ://docs.h2o.ai/h2o/latest-stable/h2o-docs/grid-search.html, Accessed: 2020-6-20, 2020" + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] + ], + "date-time": "2020-09-07T00:00:00Z", + "timestamp": 1599436800000 }, - { - "key": "ref9", - "unstructured": "Intro to Model Tuning: Grid and Random Search, Kaggle, Koehrsen, W., Explore and run machine learning code with Kaggle Notebooks | Using data from multiple data sources, jul, 2018, ://kaggle.com/willkoehrsen/intro-to-model-tuning-grid-and-random-search, Accessed: 2020-6-20, 7" - } - ], - "container-title": [ - "Journal of Open Source Software" + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + 2020, + 9, + 7 + ] + }, + "DOI": "10.21105/joss.02331", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02284/10.21105.joss.02284.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } + "date-time": "2020-09-07T23:51:02Z", + "timestamp": 1599522662000 + }, + "page": "2331", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "Flint A simulator for biological and physiological models in ordinary and stochastic differential equations" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-7074-4561", + "authenticated-orcid": false, + "given": "Takeshi", + "family": "Abe", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0001-5519-4306", + "authenticated-orcid": false, + "given": "Yoshiyuki", + "family": "Asai", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fphys.2015.00251" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.14326/abe.3.50" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1109/SAINT.2012.40" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1137/S0036144500378302" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.pbiomolbio.2004.01.004" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btg015" + }, + { + "key": "ref7", + "doi-asserted-by": "publisher", + "DOI": "10.1145/1089014.1089020" + }, + { + "key": "ref8", + "unstructured": "Madsen, K. and Nielsen, H. B. and Tingleff, O., Methods for Non-Linear Least Squares Problems (2nd ed.), 2004, 60, Informatics and Mathematical Modelling, Technical University of Denmark, DTU, Richard Petersens Plads, Building 321, DK-2800 Kgs. Lyngby" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.3389/fphys.2010.00164" + }, + { + "key": "ref10", + "doi-asserted-by": "publisher", + "DOI": "10.1093/bioinformatics/btl485" + }, + { + "key": "ref11", + "doi-asserted-by": "publisher", + "DOI": "10.1126/science.290.5495.1358" + }, + { + "key": "ref12", + "doi-asserted-by": "publisher", + "DOI": "10.1073/pnas.0406841102" + }, + { + "key": "ref13", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.imr.2015.12.004" + }, + { + "key": "ref14", + "unstructured": "Williams, Thomas and Kelley, Colin and Merrit, E. A. and al., Gnuplot 5.2: an interactive plotting program, sep, 2017, http://www.gnuplot.info/, 9" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02331.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] ], - "deposited": { + "date-time": "2020-09-07T23:51:05Z", + "timestamp": 1599522665000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02331" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] + ] + }, + "references-count": 14, + "journal-issue": { + "issue": "53", + "published-online": { "date-parts": [ [ 2020, - 7, - 5 + 9 ] - ], - "date-time": "2020-07-05T19:51:20Z", - "timestamp": 1593978680000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02284" + ] + } + }, + "alternative-id": [ + "10.21105/joss.02331" + ], + "URL": "http://dx.doi.org/10.21105/joss.02331", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4017040\u201d", + "asserted-by": "subject" } - }, - "issued": { - "date-parts": [ - [ - 2020, - 7, - 5 - ] + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2331", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 9, + 7 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2024, + 9, + 6 ] + ], + "date-time": "2024-09-06T04:37:51Z", + "timestamp": 1725597471362 + }, + "reference-count": 21, + "publisher": "The Open Journal", + "issue": "53", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 2 + ] + ], + "date-time": "2020-09-02T00:00:00Z", + "timestamp": 1599004800000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "references-count": 9, - "journal-issue": { - "issue": "51", - "published-online": { + { + "start": { "date-parts": [ [ 2020, - 7 + 9, + 2 ] - ] - } + ], + "date-time": "2020-09-02T00:00:00Z", + "timestamp": 1599004800000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "alternative-id": [ - "10.21105/joss.02284" - ], - "URL": "http://dx.doi.org/10.21105/joss.02284", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3930366\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2284", - "asserted-by": "subject" - } + { + "start": { + "date-parts": [ + [ + 2020, + 9, + 2 + ] + ], + "date-time": "2020-09-02T00:00:00Z", + "timestamp": 1599004800000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 9, + 2 + ] + ] + }, + "DOI": "10.21105/joss.02165", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 9, + 2 ] - }, - "ISSN": [ - "2475-9066" ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } + "date-time": "2020-09-02T13:33:23Z", + "timestamp": 1599053603000 + }, + "page": "2165", + "source": "Crossref", + "is-referenced-by-count": 4, + "title": [ + "A Comprehensive and Collaborative Modeling\nFramework for Complex and Evolving Systems: Utopia" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-4667-3652", + "authenticated-orcid": false, + "given": "Lukas", + "family": "Riedel", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0001-6343-3004", + "authenticated-orcid": false, + "given": "Benjamin", + "family": "Herdeanu", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0001-7787-9496", + "authenticated-orcid": false, + "given": "Harald", + "family": "Mack", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-3858-0904", + "authenticated-orcid": false, + "given": "Yunus", + "family": "Sevinchan", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Julian", + "family": "Weninger", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "issue": "1", + "key": "holland_studying_2006", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s11424-006-0001-z", + "article-title": "Studying complex adaptive\nsystems", + "volume": "19", + "author": "Holland", + "year": "2006", + "unstructured": "Holland, J. H. (2006). Studying\ncomplex adaptive systems. Journal of Systems Science and Complexity,\n19(1), 1\u20138.\nhttps://doi.org/10.1007/s11424-006-0001-z", + "journal-title": "Journal of Systems Science and\nComplexity", + "ISSN": "http://id.crossref.org/issn/1559-7067", + "issn-type": "print" + }, + { + "issue": "3", + "key": "wolfram_statistical_1983", + "doi-asserted-by": "publisher", + "DOI": "10.1103/RevModPhys.55.601", + "article-title": "Statistical mechanics of cellular\nautomata", + "volume": "55", + "author": "Wolfram", + "year": "1983", + "unstructured": "Wolfram, S. (1983). Statistical\nmechanics of cellular automata. Reviews of Modern Physics, 55(3),\n601\u2013644.\nhttps://doi.org/10.1103/RevModPhys.55.601", + "journal-title": "Reviews of Modern Physics" + }, + { + "issue": "2", + "key": "macal_everything_2016", + "doi-asserted-by": "publisher", + "DOI": "10.1057/jos.2016.7", + "article-title": "Everything you need to know about agent-based\nmodelling and simulation", + "volume": "10", + "author": "Macal", + "year": "2016", + "unstructured": "Macal, C. M. (2016). Everything you\nneed to know about agent-based modelling and simulation. Journal of\nSimulation, 10(2), 144\u2013156.\nhttps://doi.org/10.1057/jos.2016.7", + "journal-title": "Journal of Simulation", + "ISSN": "http://id.crossref.org/issn/1747-7778", + "issn-type": "print" + }, + { + "key": "the_hdf_group_hierarchical_1997", + "article-title": "Hierarchical Data Format, Version\n5", + "author": "The HDF Group", + "year": "1997", + "unstructured": "The HDF Group. (1997). Hierarchical\nData Format, Version 5.\nhttp://www.hdfgroup.org/HDF5/" + }, + { + "issue": "1", + "key": "albert_statistical_2002", + "doi-asserted-by": "publisher", + "DOI": "10.1103/RevModPhys.74.47", + "article-title": "Statistical mechanics of complex\nnetworks", + "volume": "74", + "author": "Albert", + "year": "2002", + "unstructured": "Albert, R., & Barab\u00e1si, A.-L.\n(2002). Statistical mechanics of complex networks. Reviews of Modern\nPhysics, 74(1), 47\u201397.\nhttps://doi.org/10.1103/RevModPhys.74.47", + "journal-title": "Reviews of Modern Physics" + }, + { + "issue": "4", + "key": "boccaletti_complex_2006", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.physrep.2005.10.009", + "article-title": "Complex networks: Structure and\ndynamics", + "volume": "424", + "author": "Boccaletti", + "year": "2006", + "unstructured": "Boccaletti, S., Latora, V., Moreno,\nY., Chavez, M., & Hwang, D.-U. (2006). Complex networks: Structure\nand dynamics. Physics Reports, 424(4), 175\u2013308.\nhttps://doi.org/10.1016/j.physrep.2005.10.009", + "journal-title": "Physics Reports", + "ISSN": "http://id.crossref.org/issn/0370-1573", + "issn-type": "print" + }, + { + "issue": "02n03", + "key": "chopard_cellular_2002", + "doi-asserted-by": "publisher", + "DOI": "10.1142/S0219525902000602", + "article-title": "Cellular automata and lattice boltzmann\ntechniques: An approach to model and simulate complex\nsystems", + "volume": "05", + "author": "Chopard", + "year": "2002", + "unstructured": "Chopard, B., Dupuis, A., Masselot,\nA., & Luthi, P. (2002). Cellular automata and lattice boltzmann\ntechniques: An approach to model and simulate complex systems. Advances\nin Complex Systems, 05(02n03), 103\u2013246.\nhttps://doi.org/10.1142/S0219525902000602", + "journal-title": "Advances in Complex Systems", + "ISSN": "http://id.crossref.org/issn/0219-5259", + "issn-type": "print" + }, + { + "issue": "4", + "key": "storer_bridging_2017", + "doi-asserted-by": "publisher", + "DOI": "10.1145/3084225", + "article-title": "Bridging the Chasm: A Survey of Software\nEngineering Practice in Scientific Programming", + "volume": "50", + "author": "Storer", + "year": "2017", + "unstructured": "Storer, T. (2017). Bridging the\nChasm: A Survey of Software Engineering Practice in Scientific\nProgramming. ACM Computing Surveys (CSUR), 50(4).\nhttps://doi.org/10.1145/3084225", + "journal-title": "ACM Computing Surveys (CSUR)", + "ISSN": "http://id.crossref.org/issn/0360-0300", + "issn-type": "print" + }, + { + "issue": "1", + "key": "levin_2003_complex", + "doi-asserted-by": "publisher", + "DOI": "10.1090/S0273-0979-02-00965-5", + "article-title": "Complex adaptive systems: Exploring the\nknown, the unknown and the unknowable", + "volume": "40", + "author": "Levin", + "year": "2003", + "unstructured": "Levin, S. (2003). Complex adaptive\nsystems: Exploring the known, the unknown and the unknowable. Bulletin\nof the American Mathematical Society, 40(1), 3\u201319.\nhttps://doi.org/10.1090/S0273-0979-02-00965-5", + "journal-title": "Bulletin of the American Mathematical\nSociety" + }, + { + "key": "wilensky_1999_netlogo", + "article-title": "NetLogo", + "author": "Wilensky", + "year": "1999", + "unstructured": "Wilensky, U. (1999). NetLogo. Center\nfor Connected Learning and Computer-Based Modeling, Northwestern\nUniversity. Evanston, IL.\nhttp://ccl.northwestern.edu/netlogo/" + }, + { + "issue": "52", + "key": "sevinchan_2020_dantro", + "doi-asserted-by": "publisher", + "DOI": "10.21105/joss.02316", + "article-title": "dantro: A Python package for handling,\ntransforming, and visualizing hierarchically structured\ndata", + "volume": "5", + "author": "Sevinchan", + "year": "2020", + "unstructured": "Sevinchan, Y., Herdeanu, B., &\nTraub, J. (2020). dantro: A Python package for handling, transforming,\nand visualizing hierarchically structured data. Journal of Open Source\nSoftware, 5(52), 2316.\nhttps://doi.org/10.21105/joss.02316", + "journal-title": "Journal of Open Source\nSoftware" + }, + { + "key": "sevinchan_2019_paramspace", + "article-title": "Paramspace, Version 2.3.1", + "author": "Sevinchan", + "year": "2019", + "unstructured": "Sevinchan, Y. (2019). Paramspace,\nVersion 2.3.1. Python Package Index (PyPI).\nhttps://pypi.org/project/paramspace/" + }, + { + "key": "sevinchan_2020_iccs", + "isbn-type": "print", + "doi-asserted-by": "publisher", + "DOI": "10.1007/978-3-030-50436-6_32", + "article-title": "Boosting group-level synergies by using a\nshared modeling framework", + "volume": "12143", + "author": "Sevinchan", + "year": "2020", + "unstructured": "Sevinchan, Y., Herdeanu, B., Mack,\nH., Riedel, L., & Roth, K. (2020). Boosting group-level synergies by\nusing a shared modeling framework. In V. V. Krzhizhanovskaya, G.\nZ\u00e1vodszky, M. H. Lees, J. J. Dongarra, P. M. A. Sloot, S. Brissos, &\nJ. Teixeira (Eds.), Computational Science \u2013 ICCS 2020 (Vol. 12143, pp.\n442\u2013456). Springer International Publishing.\nhttps://doi.org/10.1007/978-3-030-50436-6_32", + "ISBN": "http://id.crossref.org/isbn/9783030504366", + "journal-title": "Computational Science \u2013 ICCS\n2020" + }, + { + "key": "herdeanu_2020_arxiv", + "article-title": "Utopia: A comprehensive modeling framework\nfor complex and evolving systems", + "author": "Herdeanu", + "year": "2020", + "unstructured": "Herdeanu, B., Mack, H., Riedel, L.,\n& Sevinchan, Y. (2020). Utopia: A comprehensive modeling framework\nfor complex and evolving systems. In\npreparation." + }, + { + "issue": "10", + "key": "kanewala_2014_testing", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.infsof.2014.05.006", + "article-title": "Testing scientific software: A systematic\nliterature review", + "volume": "56", + "author": "Kanewala", + "year": "2014", + "unstructured": "Kanewala, U., & Bieman, J. M.\n(2014). Testing scientific software: A systematic literature review.\nInformation and Software Technology, 56(10), 1219\u20131232.\nhttps://doi.org/10.1016/j.infsof.2014.05.006", + "journal-title": "Information and Software\nTechnology" + }, + { + "issue": "42", + "key": "vahdati_agentsjl_2019", + "doi-asserted-by": "publisher", + "DOI": "10.21105/joss.01611", + "article-title": "Agents.jl: Agent-based modeling framework in\nJulia", + "volume": "4", + "author": "Vahdati", + "year": "2019", + "unstructured": "Vahdati, A. (2019). Agents.jl:\nAgent-based modeling framework in Julia. Journal of Open Source\nSoftware, 4(42), 1611.\nhttps://doi.org/10.21105/joss.01611", + "journal-title": "Journal of Open Source\nSoftware", + "ISSN": "http://id.crossref.org/issn/2475-9066", + "issn-type": "print" + }, + { + "key": "cardinot_evoplex_2019", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.softx.2019.02.009", + "article-title": "Evoplex: A platform for agent-based modeling\non networks", + "volume": "9", + "author": "Cardinot", + "year": "2019", + "unstructured": "Cardinot, M., O\u2019Riordan, C.,\nGriffith, J., & Perc, M. (2019). Evoplex: A platform for agent-based\nmodeling on networks. SoftwareX, 9, 199\u2013204.\nhttps://doi.org/10.1016/j.softx.2019.02.009", + "journal-title": "SoftwareX", + "ISSN": "http://id.crossref.org/issn/2352-7110", + "issn-type": "print" + }, + { + "key": "masad_2015_mesa", + "doi-asserted-by": "publisher", + "DOI": "10.25080/Majora-7b98e3ed-009", + "article-title": "Mesa: An agent-based modeling\nframework", + "author": "Masad", + "year": "2015", + "unstructured": "Masad, D., & Kazil, J. (2015).\nMesa: An agent-based modeling framework. In K. Huff & J. Bergstra\n(Eds.), Proceedings of the 14th Python in Science Conference (pp.\n51\u201358).\nhttps://doi.org/10.25080/Majora-7b98e3ed-009", + "journal-title": "Proceedings of the 14th Python in Science\nConference" + }, + { + "key": "Drossel1992", + "doi-asserted-by": "publisher", + "DOI": "10.1103/PhysRevLett.69.1629", + "article-title": "Self-organized critical forest-fire\nmodel", + "volume": "69", + "author": "Drossel", + "year": "1992", + "unstructured": "Drossel, B., & Schwabl, F.\n(1992). Self-organized critical forest-fire model. Phys. Rev. Lett., 69,\n1629\u20131632.\nhttps://doi.org/10.1103/PhysRevLett.69.1629", + "journal-title": "Phys. Rev. Lett." + }, + { + "issue": "2", + "key": "sanderson_armadillo_2016", + "doi-asserted-by": "publisher", + "DOI": "10.21105/joss.00026", + "article-title": "Armadillo: A template-based C++ library for\nlinear algebra", + "volume": "1", + "author": "Sanderson", + "year": "2016", + "unstructured": "Sanderson, C., & Curtin, R.\n(2016). Armadillo: A template-based C++ library for linear algebra.\nJournal of Open Source Software, 1(2), 26.\nhttps://doi.org/10.21105/joss.00026", + "journal-title": "Journal of Open Source\nSoftware" + }, + { + "key": "sanderson_matrix_2018", + "isbn-type": "print", + "doi-asserted-by": "publisher", + "DOI": "10.1007/978-3-319-96418-8_50", + "article-title": "A\u00a0user-friendly\u00a0hybrid\nsparse\u00a0matrix\u00a0class\u00a0in\u00a0C++", + "author": "Sanderson", + "year": "2018", + "unstructured": "Sanderson, C., & Curtin, R.\n(2018). A\u00a0user-friendly\u00a0hybrid sparse\u00a0matrix\u00a0class\u00a0in\u00a0C++. In J. H.\nDavenport, M. Kauers, G. Labahn, & J. Urban (Eds.), Mathematical\nsoftware \u2013 ICMS 2018 (pp. 422\u2013430). Springer International Publishing.\nhttps://doi.org/10.1007/978-3-319-96418-8_50", + "ISBN": "http://id.crossref.org/isbn/9783319964188", + "journal-title": "Mathematical software \u2013 ICMS\n2018" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02165.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2022, + 8, + 25 + ] ], - "published": { + "date-time": "2022-08-25T16:33:26Z", + "timestamp": 1661445206000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02165" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 9, + 2 + ] + ] + }, + "references-count": 21, + "journal-issue": { + "issue": "53", + "published-online": { "date-parts": [ [ 2020, - 7, - 5 + 9 ] ] } }, - { - "indexed": { - "date-parts": [ - [ - 2022, - 4, - 4 - ] - ], - "date-time": "2022-04-04T20:55:20Z", - "timestamp": 1649105720985 - }, - "reference-count": 5, - "publisher": "The Open Journal", - "issue": "48", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 4, - 13 - ] - ], - "date-time": "2020-04-13T00:00:00Z", - "timestamp": 1586736000000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 4, - 13 - ] - ], - "date-time": "2020-04-13T00:00:00Z", - "timestamp": 1586736000000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, + "alternative-id": [ + "10.21105/joss.02165" + ], + "URL": "http://dx.doi.org/10.21105/joss.02165", + "relation": { + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2165", + "asserted-by": "subject" + } + ], + "references": [ { - "start": { - "date-parts": [ - [ - 2020, - 4, - 13 - ] - ], - "date-time": "2020-04-13T00:00:00Z", - "timestamp": 1586736000000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" + "id-type": "doi", + "id": "10.5281/zenodo.4011979", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 9, + 2 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 3, + 30 + ] ], - "content-domain": { - "domain": [], - "crossmark-restriction": false + "date-time": "2022-03-30T02:07:11Z", + "timestamp": 1648606031350 + }, + "reference-count": 12, + "publisher": "The Open Journal", + "issue": "52", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ], + "date-time": "2020-08-21T00:00:00Z", + "timestamp": 1597968000000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "short-container-title": [ - "JOSS" + { + "start": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ], + "date-time": "2020-08-21T00:00:00Z", + "timestamp": 1597968000000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ], + "date-time": "2020-08-21T00:00:00Z", + "timestamp": 1597968000000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ] + }, + "DOI": "10.21105/joss.02404", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] ], - "published-print": { - "date-parts": [ - [ - 2020, - 4, - 13 - ] + "date-time": "2020-08-21T10:36:10Z", + "timestamp": 1598006170000 + }, + "page": "2404", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": 9999, + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0003-3662-7203", + "authenticated-orcid": false, + "given": "Mathew", + "family": "Schwartz", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-8292-7189", + "authenticated-orcid": false, + "given": "Todd", + "family": "Pataky", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Cyril", + "family": "Donnelly", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1145/2448196.2448199" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1145/2822013.2822039" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1109/tnsre.2013.2291907" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.23919/eusipco.2017.8081163" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1109/tnsre.2019.2907483" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1145/956750.956777" + }, + { + "key": "ref7", + "doi-asserted-by": "crossref", + "unstructured": "Statstream: Statistical monitoring of thousands of data streams in real time, Zhu, Yunyue and Shasha, Dennis, VLDB\u201902: Proceedings of the 28th International Conference on Very Large Databases, 358\u2013369, 2002, Elsevier", + "DOI": "10.1016/B978-155860869-6/50039-1" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1145/1081870.1081966" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1109/tnsre.2013.2260561" + }, + { + "key": "ref10", + "unstructured": "Automated time series segmentation for human motion analysis, Bouchard, Durell, Center for Human Modeling and Simulation, University of Pennsylvania, 2006, Citeseer" + }, + { + "key": "ref11", + "doi-asserted-by": "publisher", + "DOI": "10.1109/hic.2016.7797709" + }, + { + "key": "ref12", + "doi-asserted-by": "publisher", + "DOI": "10.1371/journal.pone.0211466" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02404.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 8, + 21 ] - }, - "DOI": "10.21105/joss.02145", - "type": "journal-article", - "created": { + ], + "date-time": "2020-08-21T10:36:13Z", + "timestamp": 1598006173000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02404" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ] + }, + "references-count": 12, + "journal-issue": { + "issue": "52", + "published-online": { "date-parts": [ [ 2020, - 4, - 13 + 8 ] - ], - "date-time": "2020-04-13T12:09:48Z", - "timestamp": 1586779788000 - }, - "page": "2145", - "source": "Crossref", - "is-referenced-by-count": 0, - "title": "Visions: An Open-Source Library for Semantic Data", - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0001-9866-7767", - "authenticated-orcid": false, - "given": "Simon", - "family": "Brugman", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0001-6788-8188", - "authenticated-orcid": false, - "given": "Ian", - "family": "Eaves", - "sequence": "additional", - "affiliation": [] + ] + } + }, + "alternative-id": [ + "10.21105/joss.02404" + ], + "URL": "http://dx.doi.org/10.21105/joss.02404", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3979649\u201d", + "asserted-by": "subject" } ], - "member": "8722", - "reference": [ + "has-review": [ { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.5281/zenodo.3644238" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1109/MCSE.2011.37" + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2404", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 8, + 21 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 3, + 30 + ] + ], + "date-time": "2022-03-30T05:18:58Z", + "timestamp": 1648617538538 + }, + "reference-count": 7, + "publisher": "The Open Journal", + "issue": "47", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ], + "date-time": "2020-03-20T00:00:00Z", + "timestamp": 1584662400000 }, - { - "key": "ref3", - "unstructured": "Hagberg, Aric A. and Schult, Daniel A. and Swart, Pieter J., Exploring Network Structure, Dynamics, and Function using NetworkX, Proceedings of the 7th Python in Science Conference, 11 - 15, Pasadena, CA USA, 2008, Varoquaux, Ga\u00ebl and Vaught, Travis and Millman, Jarrod" + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ], + "date-time": "2020-03-20T00:00:00Z", + "timestamp": 1584662400000 }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.5281/zenodo.3545747" + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ], + "date-time": "2020-03-20T00:00:00Z", + "timestamp": 1584662400000 }, - { - "key": "ref5", - "unstructured": "Brugman, Simon, pandas-profiling: exploratory data analysis reports in Python, 2020, https://github.com/pandas-profiling/pandas-profiling, Version: 2.4.0, Accessed: 01/02/2020" - } - ], - "container-title": [ - "Journal of Open Source Software" + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ] + }, + "DOI": "10.21105/joss.02074", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02145/10.21105.joss.02145.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } + "date-time": "2020-03-20T11:18:11Z", + "timestamp": 1584703091000 + }, + "page": "2074", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "pyGOURGS - global optimization of n-ary tree representable problems using uniform random global search" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-3050-8943", + "authenticated-orcid": false, + "given": "Sohrab", + "family": "Towfighi", + "sequence": "first", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1109/4235.585893" + }, + { + "key": "ref2", + "unstructured": "Tychonievich, Luther, Luther\u2019s Meanderings, symbolic regression, Enumerating Trees, https://www.cs.virginia.edu/\u00a0lat7h/blog/posts/434.html, 2019-06-14, 2013" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1186/s13040-018-0164-x" + }, + { + "key": "ref4", + "unstructured": "DEAP: Evolutionary algorithms made easy, Fortin, F\u00e9lix-Antoine and Rainville, Fran\u00e7ois-Michel De and Gardner, Marc-Andr\u00e9 and Parizeau, Marc and Gagn\u00e9, Christian, Journal of Machine Learning Research, 13, Jul, 2171\u20132175, 2012" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1287/moor.6.1.19" + }, + { + "key": "ref6", + "unstructured": "Langdon, W. B. and Poli, R., Why Ants are Hard, Proceedings of the Third Annual Conference on Genetic Programming (GP98), 1998, Koza, John R. and Banzhaf, Wolfgang and Chellapilla, Kumar and Deb, Kalyanmoy and Dorigo, Marco and Fogel, David B. and Garzon, Max H. and Goldberg, David E. and Iba, Hitoshi and Riolo, Rick, 193\u2013201, University of Wisconsin, Madison, Wisconsin, USA, San Francisco, CA, USA, Morgan Kaufmann, http://www.cs.ucl.ac.uk/staff/W.Langdon/ftp/papers/WBL.antspace_gp98.pdf" + }, + { + "key": "ref7", + "doi-asserted-by": "publisher", + "DOI": "10.21105/joss.01675" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.02074/10.21105.joss.02074.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] ], - "deposited": { + "date-time": "2020-03-20T11:18:14Z", + "timestamp": 1584703094000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02074" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ] + }, + "references-count": 7, + "journal-issue": { + "issue": "47", + "published-online": { "date-parts": [ [ 2020, - 4, - 13 + 3 ] - ], - "date-time": "2020-04-13T12:09:55Z", - "timestamp": 1586779795000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02145" + ] + } + }, + "alternative-id": [ + "10.21105/joss.02074" + ], + "URL": "http://dx.doi.org/10.21105/joss.02074", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3710475\u201d", + "asserted-by": "subject" } - }, - "issued": { - "date-parts": [ - [ - 2020, - 4, - 13 - ] + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2074", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 3, + 20 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2024, + 8, + 6 ] + ], + "date-time": "2024-08-06T08:34:16Z", + "timestamp": 1722933256514 + }, + "reference-count": 17, + "publisher": "The Open Journal", + "issue": "52", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 8, + 24 + ] + ], + "date-time": "2020-08-24T00:00:00Z", + "timestamp": 1598227200000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 8, + 24 + ] + ], + "date-time": "2020-08-24T00:00:00Z", + "timestamp": 1598227200000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "references-count": 5, - "journal-issue": { - "issue": "48", - "published-online": { + { + "start": { "date-parts": [ [ 2020, - 4 + 8, + 24 ] - ] - } - }, - "alternative-id": [ - "10.21105/joss.02145" - ], - "URL": "http://dx.doi.org/10.21105/joss.02145", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3748758\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2145", - "asserted-by": "subject" - } + ], + "date-time": "2020-08-24T00:00:00Z", + "timestamp": 1598227200000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 8, + 24 + ] + ] + }, + "DOI": "10.21105/joss.02313", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 8, + 24 ] - }, - "ISSN": [ - "2475-9066" ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } + "date-time": "2020-08-24T14:28:12Z", + "timestamp": 1598279292000 + }, + "page": "2313", + "source": "Crossref", + "is-referenced-by-count": 2, + "title": [ + "DORiE: A Discontinuous Galerkin Solver for Soil Water\nFlow and Passive Solute Transport Based on DUNE" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-4667-3652", + "authenticated-orcid": false, + "given": "Lukas", + "family": "Riedel", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-0814-9670", + "authenticated-orcid": false, + "given": "Santiago Ospina De Los", + "family": "R\u00edos", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-4465-7317", + "authenticated-orcid": false, + "given": "Dion", + "family": "H\u00e4fner", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-3295-7347", + "authenticated-orcid": false, + "given": "Ole", + "family": "Klein", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "issue": "4", + "key": "ern_posteriori_2008", + "article-title": "A posteriori energy-norm error estimates for\nadvection-diffusion equations approximated by weighted interior penalty\nmethods", + "volume": "26", + "author": "Ern", + "year": "2008", + "unstructured": "Ern, A., & Stephansen, A. F.\n(2008). A posteriori energy-norm error estimates for advection-diffusion\nequations approximated by weighted interior penalty methods. Journal of\nComputational Mathematics, 26(4), 488\u2013510.\nhttps://www.jstor.org/stable/43693458", + "journal-title": "Journal of Computational\nMathematics" + }, + { + "key": "ern_discontinuous_2009", + "doi-asserted-by": "publisher", + "DOI": "10.1093/imanum/drm050", + "article-title": "A discontinuous Galerkin method with weighted\naverages for advection\u2013diffusion equations with locally small and\nanisotropic diffusivity", + "volume": "29", + "author": "Ern", + "year": "2009", + "unstructured": "Ern, A., Stephansen, A. F., &\nZunino, P. (2009). A discontinuous Galerkin method with weighted\naverages for advection\u2013diffusion equations with locally small and\nanisotropic diffusivity. IMA Journal of Numerical Analysis, 29, 235\u2013256.\nhttps://doi.org/10.1093/imanum/drm050", + "journal-title": "IMA Journal of Numerical\nAnalysis" + }, + { + "key": "miller_numerical_2013", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.advwatres.2012.05.008", + "article-title": "Numerical simulation of water resources\nproblems: Models, methods, and trends", + "volume": "51", + "author": "Miller", + "year": "2013", + "unstructured": "Miller, C. T., Dawson, C. N.,\nFarthing, M. W., Hou, T. Y., Huang, J., Kees, C. E., Kelley, C. T.,\n& Langtangen, H. P. (2013). Numerical simulation of water resources\nproblems: Models, methods, and trends. Advances in Water Resources, 51,\n405\u2013437.\nhttps://doi.org/10.1016/j.advwatres.2012.05.008", + "journal-title": "Advances in Water Resources" + }, + { + "key": "schroeder_visualization_2006", + "isbn-type": "print", + "volume-title": "The Visualization Toolkit", + "author": "Schroeder", + "year": "2006", + "unstructured": "Schroeder, W., Martin, K., &\nLorensen, B. (2006). The Visualization Toolkit (A. Squillacote, Ed.; 4th\ned.). Kitware, Inc. ISBN:\u00a0978-1-930934-19-1", + "ISBN": "http://id.crossref.org/isbn/9781930934191" + }, + { + "issue": "2", + "key": "bastian_generic_2010", + "article-title": "Generic implementation of finite element\nmethods in the Distributed and Unified Numerics Environment\n(DUNE)", + "volume": "46", + "author": "Bastian", + "year": "2010", + "unstructured": "Bastian, P., Heimann, F., &\nMarnach, S. (2010). Generic implementation of finite element methods in\nthe Distributed and Unified Numerics Environment (DUNE). Kybernetika,\n46(2), 294\u2013315. dml.cz/dmlcz/140745", + "journal-title": "Kybernetika" + }, + { + "issue": "100", + "key": "blatt_distributed_2016", + "doi-asserted-by": "publisher", + "DOI": "10.11588/ans.2016.100.26526", + "article-title": "The Distributed and Unified Numerics\nEnvironment, Version 2.4", + "volume": "4", + "author": "Blatt", + "year": "2016", + "unstructured": "Blatt, M., Burchardt, A., Dedner, A.,\nEngwer, C., Fahlke, J., Flemisch, B., Gersbacher, C., Gr\u00e4ser, C.,\nGruber, F., Gr\u00fcninger, C., Kempf, D., Kl\u00f6fkorn, R., Malkmus, T.,\nM\u00fcthing, S., Nolte, M., Piatkowski, M., & Sander, O. (2016). The\nDistributed and Unified Numerics Environment, Version 2.4. Archive of\nNumerical Software, 4(100), 13\u201329.\nhttps://doi.org/10.11588/ans.2016.100.26526", + "journal-title": "Archive of Numerical Software" + }, + { + "key": "di_pietro_mathematical_2012", + "doi-asserted-by": "publisher", + "DOI": "10.1007/978-3-642-22980-0", + "volume-title": "Mathematical Aspects of Disconinuous Galerkin\nMethods", + "author": "Di Pietro", + "year": "2012", + "unstructured": "Di Pietro, D. A., & Ern, A.\n(2012). Mathematical Aspects of Disconinuous Galerkin Methods (G.\nAllaire & J. Garnier, Eds.). Springer.\nhttps://doi.org/10.1007/978-3-642-22980-0" + }, + { + "issue": "5", + "key": "bastian_fully-coupled_2014", + "doi-asserted-by": "publisher", + "DOI": "10.1007/s10596-014-9426-y", + "article-title": "A fully-coupled discontinuous Galerkin method\nfor two-phase flow in porous media with discontinuous capillary\npressure", + "volume": "18", + "author": "Bastian", + "year": "2014", + "unstructured": "Bastian, P. (2014). A fully-coupled\ndiscontinuous Galerkin method for two-phase flow in porous media with\ndiscontinuous capillary pressure. Computational Geosciences, 18(5),\n779\u2013796.\nhttps://doi.org/10.1007/s10596-014-9426-y", + "journal-title": "Computational Geosciences", + "ISSN": "http://id.crossref.org/issn/1573-1499", + "issn-type": "print" + }, + { + "issue": "12", + "key": "ern_accurate_2007", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.crma.2007.10.036", + "article-title": "An accurate H(div) flux reconstruction for\ndiscontinuous Galerkin approximations of elliptic\nproblems", + "volume": "345", + "author": "Ern", + "year": "2007", + "unstructured": "Ern, A., Nicaise, S., & Vohral\u00edk,\nM. (2007). An accurate H(div) flux reconstruction for discontinuous\nGalerkin approximations of elliptic problems. Comptes Rendus\nMathematique, 345(12), 709\u2013712.\nhttps://doi.org/10.1016/j.crma.2007.10.036", + "journal-title": "Comptes Rendus Mathematique", + "ISSN": "http://id.crossref.org/issn/1631-073X", + "issn-type": "print" + }, + { + "issue": "11", + "key": "geuzaine_gmsh_2009", + "doi-asserted-by": "publisher", + "DOI": "10.1002/nme.2579", + "article-title": "Gmsh: A 3-D finite element mesh generator\nwith built-in pre- and post-processing facilities", + "volume": "79", + "author": "Geuzaine", + "year": "2009", + "unstructured": "Geuzaine, C., & Remacle, J.-F.\n(2009). Gmsh: A 3-D finite element mesh generator with built-in pre- and\npost-processing facilities. International Journal for Numerical Methods\nin Engineering, 79(11), 1309\u20131331.\nhttps://doi.org/10.1002/nme.2579", + "journal-title": "International Journal for Numerical Methods\nin Engineering", + "ISSN": "http://id.crossref.org/issn/1097-0207", + "issn-type": "print" + }, + { + "key": "the_hdf_group_hierarchical_1997", + "article-title": "Hierarchical Data Format, Version\n5", + "author": "The HDF Group", + "year": "1997", + "unstructured": "The HDF Group. (1997). Hierarchical\nData Format, Version 5.\nhttp://www.hdfgroup.org/HDF5/" + }, + { + "issue": "1", + "key": "vogel_scale_2019", + "doi-asserted-by": "publisher", + "DOI": "10.2136/vzj2019.01.0001", + "article-title": "Scale issues in soil\nhydrology", + "volume": "18", + "author": "Vogel", + "year": "2019", + "unstructured": "Vogel, H.-J. (2019). Scale issues in\nsoil hydrology. Vadose Zone Journal, 18(1).\nhttps://doi.org/10.2136/vzj2019.01.0001", + "journal-title": "Vadose Zone Journal", + "ISSN": "http://id.crossref.org/issn/1539-1663", + "issn-type": "print" + }, + { + "key": "ole_klein_dune_2020", + "article-title": "DUNE Randomfield", + "author": "Klein", + "year": "2016", + "unstructured": "Klein, O. (2016). DUNE Randomfield\n[{GitLab} {Repository}].\nhttps://gitlab.dune-project.org/oklein/dune-randomfield" + }, + { + "key": "hannes_h_bauser_challenges_2020", + "doi-asserted-by": "publisher", + "DOI": "10.1002/vzj2.20040", + "article-title": "Challenges with effective representations of\nheterogeneity in soil hydrology based on local water content\nmeasurements", + "volume": "19", + "author": "Bauser", + "year": "2020", + "unstructured": "Bauser, H. H., Riedel, L., Berg, D.,\nTroch, P., & Roth, K. (2020). Challenges with effective\nrepresentations of heterogeneity in soil hydrology based on local water\ncontent measurements. Vadose Zone Journal, 19, e20040.\nhttps://doi.org/10.1002/vzj2.20040", + "journal-title": "Vadose Zone Journal" + }, + { + "issue": "9", + "key": "li_adaptive_2007", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.advwatres.2007.02.007", + "article-title": "Adaptive local discontinuous Galerkin\napproximation to Richards\u2019 equation", + "volume": "30", + "author": "Li", + "year": "2007", + "unstructured": "Li, H., Farthing, Matthew W., &\nMiller, C. T. (2007). Adaptive local discontinuous Galerkin\napproximation to Richards\u2019 equation. Advances in Water Resources, 30(9),\n1883\u20131901.\nhttps://doi.org/10.1016/j.advwatres.2007.02.007", + "journal-title": "Advances in Water Resources" + }, + { + "issue": "6", + "key": "farthing_numerical_2017", + "doi-asserted-by": "publisher", + "DOI": "10.2136/sssaj2017.02.0058", + "article-title": "Numerical solution of Richards\u2019 equation: A\nreview of advances and challenges", + "volume": "81", + "author": "Farthing", + "year": "2017", + "unstructured": "Farthing, M. W., & Ogden, F. L.\n(2017). Numerical solution of Richards\u2019 equation: A review of advances\nand challenges. Soil Science Society of America Journal, 81(6),\n1257\u20131269.\nhttps://doi.org/10.2136/sssaj2017.02.0058", + "journal-title": "Soil Science Society of America\nJournal", + "ISSN": "http://id.crossref.org/issn/0361-5995", + "issn-type": "print" + }, + { + "issue": "9", + "key": "flemisch_dumux_2011", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.advwatres.2011.03.007", + "article-title": "DuMux: DUNE for\nmulti-{phase,component,scale,physics,\u2026} flow and transport in porous\nmedia", + "volume": "34", + "author": "Flemisch", + "year": "2011", + "unstructured": "Flemisch, B., Darcis, M.,\nErbertseder, K., Faigle, B., Lauser, A., Mosthaf, K., M\u00fcthing, S.,\nNuske, P., Tatomir, A., Wolff, M., & Helmig, R. (2011). DuMux: DUNE\nfor multi-{phase,component,scale,physics,\u2026} flow and transport in porous\nmedia. Advances in Water Resources, 34(9), 1102\u20131112.\nhttps://doi.org/10.1016/j.advwatres.2011.03.007", + "journal-title": "Advances in Water Resources" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02313.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2022, + 8, + 25 + ] ], - "published": { + "date-time": "2022-08-25T16:51:48Z", + "timestamp": 1661446308000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02313" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 8, + 24 + ] + ] + }, + "references-count": 17, + "journal-issue": { + "issue": "52", + "published-online": { "date-parts": [ [ 2020, - 4, - 13 + 8 ] ] } }, - { - "indexed": { - "date-parts": [ - [ - 2024, - 9, - 12 - ] - ], - "date-time": "2024-09-12T13:53:46Z", - "timestamp": 1726149226135 - }, - "reference-count": 9, - "publisher": "The Open Journal", - "issue": "46", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 2, - 6 - ] - ], - "date-time": "2020-02-06T00:00:00Z", - "timestamp": 1580947200000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 2, - 6 - ] - ], - "date-time": "2020-02-06T00:00:00Z", - "timestamp": 1580947200000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, + "alternative-id": [ + "10.21105/joss.02313" + ], + "URL": "http://dx.doi.org/10.21105/joss.02313", + "relation": { + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2313", + "asserted-by": "subject" + } + ], + "references": [ { - "start": { - "date-parts": [ - [ - 2020, - 2, - 6 - ] - ], - "date-time": "2020-02-06T00:00:00Z", - "timestamp": 1580947200000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" + "id-type": "doi", + "id": "10.5281/zenodo.3997152", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 8, + 24 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 4, + 1 + ] ], - "content-domain": { - "domain": [], - "crossmark-restriction": false + "date-time": "2022-04-01T20:55:25Z", + "timestamp": 1648846525658 + }, + "reference-count": 21, + "publisher": "The Open Journal", + "issue": "56", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ], + "date-time": "2020-12-03T00:00:00Z", + "timestamp": 1606953600000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "short-container-title": [ - "JOSS" + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ], + "date-time": "2020-12-03T00:00:00Z", + "timestamp": 1606953600000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ], + "date-time": "2020-12-03T00:00:00Z", + "timestamp": 1606953600000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ] + }, + "DOI": "10.21105/joss.02444", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] ], - "published-print": { - "date-parts": [ - [ - 2020, - 2, - 6 - ] + "date-time": "2020-12-03T22:28:58Z", + "timestamp": 1607034538000 + }, + "page": "2444", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "TBFMM: A C++ generic and parallel fast multipole method library" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0003-0281-9709", + "authenticated-orcid": false, + "given": "Berenger", + "family": "Bramas", + "sequence": "first", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1016/0021-9991(87)90140-9" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1109/aps.1994.407723" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1109/tpds.2017.2697857" + }, + { + "key": "ref4", + "unstructured": "OpenMP Architecture Review Board, OpenMP Application Program Interface, jul, 2013, https://www.openmp.org/wp-content/uploads/OpenMP4.0.0.pdf, 7" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1155/2017/5482468" + }, + { + "key": "ref6", + "unstructured": "Task-based fast multipole method for clusters of multicore processors, Agullo, Emmanuel and Bramas, B\u00e9renger and Coulaud, Olivier and Khannouz, Martin and Stanisic, Luka, https://hal.inria.fr/hal-01387482, Research Report, RR-8970, 15 , Inria Bordeaux Sud-Ouest, 2017, mar, multicore processor ; high performance computing (HPC) ; fast multipole method ; hybrid parallelization ; runtime system ; task-based programming ; cluster ; FMM ; m\u00e9thode multip\u00f4les rapide ; Calcul haute performance ; architecture multic; moteur d\u2019ex\u00e9cution ; parall\u00e9lisation hybride ; programmation \u00e0 base de t\u00e2ches ; MPI ; OpenMP, https://hal.inria.fr/hal-01387482/file/report-8970.pdf, hal-01387482, v4, 3" + }, + { + "key": "ref7", + "unstructured": "Optimization and parallelization of the boundary element method for the wave equation in time domain, Bramas, B\u00e9renger, 2016, Bordeaux" + }, + { + "key": "ref8", + "unstructured": "The best of the 20th century: Editors name top 10 algorithms, Cipra, Barry A, SIAM news, 33, 4, 1\u20132, 2000" + }, + { + "key": "ref9", + "unstructured": "Fast hierarchical algorithms for generating Gaussian random fields, Blanchard, Pierre and Coulaud, Olivier and Darve, Eric, https://hal.inria.fr/hal-01228519, Research Report, Inria Bordeaux Sud-Ouest, 2015, nov, H 2 -methods ; FMM ; FFT ; randomized SVD ; covariance kernel matrices ; multivariate Gaussian random variables, https://hal.inria.fr/hal-01228519v1/file/RR-8811.pdf, hal-01228519, v1, 11" + }, + { + "key": "ref10", + "unstructured": "An Efficient Interpolation Based FMM for Dislocation Dynamics Simulations, Blanchard, Pierre and Coulaud, Olivier and Etcheverry, Arnaud and Dupuy, Laurent and Darve, Eric, https://hal.archives-ouvertes.fr/hal-01334842, Platform for Advanced Scientific Computing, Lausanne, Switzerland, USI and CSCS and EPFL, 2016, jun, hal-01334842, v1, 6" + }, + { + "key": "ref11", + "unstructured": "Optimizing the Black-box FMM for Smooth and Oscillatory Kernels, Darve, Eric and Messner, Matthias and Schanz, Martin and Coulaud, Olivier, https://hal.inria.fr/hal-00799885, SIAM Conference on Computational Science and Engineering (SIAM CSE 2013), Boston, United States, 2013, feb, optimisation ; Fast multipole method ; symmetry ; BLAS, hal-00799885, v1, 2" + }, + { + "key": "ref12", + "doi-asserted-by": "crossref", + "unstructured": "A fast multipole method for Maxwell equations stable at all frequencies, Darve, Eric and Hav\u00e9, Pascal, Philosophical Transactions of the Royal Society of London. Series A: Mathematical, Physical and Engineering Sciences, 362, 1816, 603\u2013628, 2004, The Royal Society", + "DOI": "10.1098/rsta.2003.1337" + }, + { + "key": "ref13", + "doi-asserted-by": "publisher", + "DOI": "10.4208/cicp.020215.150515sw" + }, + { + "key": "ref14", + "unstructured": "ExaFMM: An open source library for Fast Multipole Methods aimed towards Exascale systems, Barba, L and Yokota, Rio, Boston: Boston University. Retrieved from barbagroup: http://barbagroup. bu. edu, 2011" + }, + { + "key": "ref15", + "unstructured": "Coupled Fast Multipole Method-Finite Element Method for the analysis of magneto-mechanical problems, Frangi, Attilio and Faure-Ragani, Paolo and Ghezzi, Luca, Proceedings of the Sixth French National Congress\" Calcul des structures, 273\u2013280, 2003" + }, + { + "key": "ref16", + "unstructured": "The fast multipole method for electromagnetic field computation in numerical and physical hybrid systems, Vazquez Sabariego, Ruth, 2004, Universit\u00e9 de Li\u00e8ge" + }, + { + "key": "ref17", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.enganabound.2012.07.004" + }, + { + "key": "ref18", + "unstructured": "Hierarchical Randomized Low-Rank Approximations, Blanchard, Pierre and Coulaud, Olivier and Darve, E and Bramas, B, https://hal.archives-ouvertes.fr/hal-01255724, SIAM Conference on Applied Linear Algebra (SIAM LA), Atlanta, United States, SIAM, 2015, oct, hal-01255724, v1, 10" + }, + { + "key": "ref19", + "unstructured": "Implementation of rotation-based operators for fast multipole method in X10, Haigh, Andrew, 2011, Austrailian National University" + }, + { + "key": "ref20", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.cam.2003.12.011" + }, + { + "key": "ref21", + "doi-asserted-by": "publisher", + "DOI": "10.1145/1654059.1654118" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02444.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 12, + 3 ] - }, - "DOI": "10.21105/joss.02071", - "type": "journal-article", - "created": { + ], + "date-time": "2020-12-03T22:29:56Z", + "timestamp": 1607034596000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02444" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ] + }, + "references-count": 21, + "journal-issue": { + "issue": "56", + "published-online": { "date-parts": [ [ 2020, - 2, - 6 + 12 ] - ], - "date-time": "2020-02-06T16:11:05Z", - "timestamp": 1581005465000 - }, - "page": "2071", - "source": "Crossref", - "is-referenced-by-count": 14, - "title": [ - "osfr: An R Interface to the Open Science Framework" + ] + } + }, + "alternative-id": [ + "10.21105/joss.02444" + ], + "URL": "http://dx.doi.org/10.21105/joss.02444", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4302384\u201d", + "asserted-by": "subject" + } ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0003-2542-2202", - "authenticated-orcid": false, - "given": "Aaron", - "family": "Wolen", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-1050-6809", - "authenticated-orcid": false, - "given": "Chris", - "family": "Hartgerink", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Ryan", - "family": "Hafen", - "sequence": "additional", - "affiliation": [] - }, - { - "given": "Brian", - "family": "Richards", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-1227-7042", - "authenticated-orcid": false, - "given": "Courtney", - "family": "Soderberg", - "sequence": "additional", - "affiliation": [] - }, + "has-review": [ { - "ORCID": "http://orcid.org/0000-0003-4068-4286", - "authenticated-orcid": false, - "given": "Timothy", - "family": "York", - "sequence": "additional", - "affiliation": [] + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2444", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 12, + 3 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 4, + 5 + ] ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "unstructured": "crul: HTTP Client, Chamberlain, Scott, 2019, R package version 0.9.0, https://CRAN.R-project.org/package=crul" - }, - { - "key": "ref2", - "unstructured": "googledrive: An Interface to Google Drive, D\u2019Agostino McGowan, Lucy and Bryan, Jennifer, 2019, R package version 1.0.0, https://cran.r-project.org/package=googledrive" - }, - { - "key": "ref3", - "unstructured": "magrittr: A Forward-Pipe Operator for R, Bache, Stefan Milton and Wickham, Hadley, 2014, R package version 1.5, https://CRAN.R-project.org/package=magrittr" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1186/1751-0473-8-7" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1371/journal.pcbi.1003285" - }, - { - "key": "ref6", - "unstructured": "tibble: Simple Data Frames, M\u00fcller, Kirill and Wickham, Hadley, 2019, R package version 2.1.3, https://CRAN.R-project.org/package=tibble" + "date-time": "2022-04-05T14:45:48Z", + "timestamp": 1649169948811 + }, + "reference-count": 4, + "publisher": "The Open Journal", + "issue": "56", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ], + "date-time": "2020-12-14T00:00:00Z", + "timestamp": 1607904000000 }, - { - "key": "ref7", - "unstructured": "stringr: Simple, Consistent Wrappers for Common String Operations, Wickham, Hadley, 2019, R package version 1.4.0, https://cran.r-project.org/package=stringr" + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ], + "date-time": "2020-12-14T00:00:00Z", + "timestamp": 1607904000000 }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1002/cpet.32" + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ], + "date-time": "2020-12-14T00:00:00Z", + "timestamp": 1607904000000 }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1371/journal.pcbi.1005510" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02071/10.21105.joss.02071.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ] + }, + "DOI": "10.21105/joss.02695", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] ], - "deposited": { + "date-time": "2020-12-14T12:30:34Z", + "timestamp": 1607949034000 + }, + "page": "2695", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "Multiscale Solar Water Heating" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "given": "Milica", + "family": "Grahovac", + "sequence": "first", + "affiliation": [] + }, + { + "given": "Katie", + "family": "Coughlin", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Hannes", + "family": "Gerhart", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Robert", + "family": "Hosbach", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "unstructured": "Costs and Benefits of Community versus Individual End-use Infrastructure for Solar Water Heating, Lawrence Berkeley National Laboratory, Coughlin, Katie and Grahovac, Milica and Ganeshalingam, Mohan and Hosbach, Robert and Vossos, Vagelis, 2021, California Energy Commission" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.11578/dc.20190524.2" + }, + { + "key": "ref3", + "unstructured": "Implementation of a Flexible Web Framework for Simulating Python System Models, en, Gerhart, Hannes, 82, 2019, Technical University of Munich, Technical University of Munich" + }, + { + "key": "ref4", + "unstructured": "Costs and Benefits of Community Scale Solar Water Heating, en, Grahovac, Milica and Coughlin, Katie and Ganeshalingam, Mohan and Hosbach, Robert and Vossos, Vagelis, 16, In Proceedings of ACEEE Summer Study 2020, 2020, https://aceee2020.conferencespot.org/event-data/pdf/catalyst_activity_10923/catalyst_activity_paper_20200812133157248_498ce455_3a9c_4278_9088_6e3fdce5745b" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02695.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ], + "date-time": "2020-12-14T12:30:35Z", + "timestamp": 1607949035000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02695" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ] + }, + "references-count": 4, + "journal-issue": { + "issue": "56", + "published-online": { "date-parts": [ [ 2020, - 2, - 6 + 12 ] - ], - "date-time": "2020-02-06T16:11:09Z", - "timestamp": 1581005469000 - }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02071" + ] + } + }, + "alternative-id": [ + "10.21105/joss.02695" + ], + "URL": "http://dx.doi.org/10.21105/joss.02695", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4305504\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2695", + "asserted-by": "subject" } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 12, + 14 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2023, + 10, + 31 + ] + ], + "date-time": "2023-10-31T18:14:43Z", + "timestamp": 1698776083707 + }, + "reference-count": 11, + "publisher": "The Open Journal", + "issue": "54", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ], + "date-time": "2020-10-29T00:00:00Z", + "timestamp": 1603929600000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "issued": { + { + "start": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ], + "date-time": "2020-10-29T00:00:00Z", + "timestamp": 1603929600000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ], + "date-time": "2020-10-29T00:00:00Z", + "timestamp": 1603929600000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ] + }, + "DOI": "10.21105/joss.02580", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ], + "date-time": "2020-10-29T06:57:11Z", + "timestamp": 1603954631000 + }, + "page": "2580", + "source": "Crossref", + "is-referenced-by-count": 1, + "title": [ + "Open Source Optical Coherence Tomography Software" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-4494-6127", + "authenticated-orcid": false, + "given": "Miroslav", + "family": "Zabic", + "sequence": "first", + "affiliation": [] + }, + { + "given": "Ben", + "family": "Matthias", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Alexander", + "family": "Heisterkamp", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Tammo", + "family": "Ripken", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1364/boe.3.003067" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1364/oe.18.011772" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1117/1.3548153" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1117/1.JBO.17.10.100502" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1109/fccm.2011.27" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1117/1.JBO.18.2.026002" + }, + { + "key": "ref7", + "doi-asserted-by": "publisher", + "DOI": "10.1364/OE.18.024395" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1364/BOE.5.002963" + }, + { + "key": "ref9", + "unstructured": "GPU-accelerated single-pass raycaster, \u200bPilia, Martino, \u200bGitHub repository, 2018, \u200bGitHub, https://github.com/m-pilia/volume-raycasting" + }, + { + "key": "ref10", + "unstructured": "Qt, 2020, https://www.qt.io, 2020-08-23" + }, + { + "key": "ref11", + "unstructured": "CUDA, \u200bNVIDIA, 2020, https://developer.nvidia.com/cuda-zone, 2020-08-23" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02580.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ], + "date-time": "2020-10-29T06:57:17Z", + "timestamp": 1603954637000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02580" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ] + }, + "references-count": 11, + "journal-issue": { + "issue": "54", + "published-online": { "date-parts": [ [ 2020, - 2, - 6 + 10 ] ] + } + }, + "alternative-id": [ + "10.21105/joss.02580" + ], + "URL": "http://dx.doi.org/10.21105/joss.02580", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4148992\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2580", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 10, + 29 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2023, + 8, + 28 + ] + ], + "date-time": "2023-08-28T17:23:59Z", + "timestamp": 1693243439260 + }, + "reference-count": 10, + "publisher": "The Open Journal", + "issue": "55", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] + ], + "date-time": "2020-11-20T00:00:00Z", + "timestamp": 1605830400000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "references-count": 9, - "journal-issue": { - "issue": "46", - "published-online": { + { + "start": { "date-parts": [ [ 2020, - 2 + 11, + 20 ] - ] - } + ], + "date-time": "2020-11-20T00:00:00Z", + "timestamp": 1605830400000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" }, - "alternative-id": [ - "10.21105/joss.02071" - ], - "URL": "http://dx.doi.org/10.21105/joss.02071", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3625248\u201d", - "asserted-by": "subject" - } - ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2071", - "asserted-by": "subject" - } + { + "start": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] + ], + "date-time": "2020-11-20T00:00:00Z", + "timestamp": 1605830400000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] + ] + }, + "DOI": "10.21105/joss.02483", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 11, + 20 ] - }, - "ISSN": [ - "2475-9066" ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } + "date-time": "2020-11-20T17:42:58Z", + "timestamp": 1605894178000 + }, + "page": "2483", + "source": "Crossref", + "is-referenced-by-count": 1, + "title": [ + "pyveg: A Python package for analysing the time evolution of patterned vegetation using Google Earth Engine" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "given": "Nick", + "family": "Barlow", + "sequence": "first", + "affiliation": [] + }, + { + "given": "Camila", + "family": "Smith", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Samuel", + "family": "Van Stroud", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Jesse", + "family": "Abrams", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Chris", + "family": "Boulton", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Joshua", + "family": "Buxton", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1098/rsos.160443" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1111/gcb.14059" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1073/pnas.0802430105" + }, + { + "key": "ref4", + "unstructured": "Euler\u2019s Gem: The Polyhedron Formula and the Birth of Topology, Richeson, D.S., 9780691154572, https://books.google.co.uk/books?id=0m8-zQEACAAJ, 2012, Princeton University Press" + }, + { + "key": "ref5", + "unstructured": "2020, Principe, R.E. et al, https://github.com/gee-community/gee_tools" + }, + { + "key": "ref6", + "unstructured": "Bury, Thomas, 2020, https://github.com/ThomasMBury/ewstools" + }, + { + "key": "ref7", + "unstructured": "ECMWF, 2020, Copernicus Climate Change Service (C3S): ERA5: Fifth generation of ECMWF atmospheric reanalyses of the global climate." + }, + { + "key": "ref8", + "unstructured": "ESA, 2020, Contains modified Copernicus Sentinel data, courtesy of ESA" + }, + { + "key": "ref9", + "unstructured": "USGS, 2020, Landsat-4, Landsat-5, Landsat-7, Landsat-8 data courtesy of the U.S. Geological Survey" + }, + { + "key": "ref10", + "unstructured": "Skwarnicki, Tomasz, A study of the radiative CASCADE transitions between the Upsilon-Prime and Upsilon resonances, PhD thesis, Cracow, INP, 1986" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02483.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] ], - "published": { + "date-time": "2020-11-20T17:43:31Z", + "timestamp": 1605894211000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02483" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] + ] + }, + "references-count": 10, + "journal-issue": { + "issue": "55", + "published-online": { "date-parts": [ [ 2020, - 2, - 6 + 11 ] ] } }, - { - "indexed": { + "alternative-id": [ + "10.21105/joss.02483" + ], + "URL": "http://dx.doi.org/10.21105/joss.02483", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.4281273\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2483", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 11, + 20 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 4, + 6 + ] + ], + "date-time": "2022-04-06T02:25:07Z", + "timestamp": 1649211907396 + }, + "reference-count": 9, + "publisher": "The Open Journal", + "issue": "51", + "license": [ + { + "start": { "date-parts": [ [ - 2024, - 8, - 10 + 2020, + 7, + 5 ] ], - "date-time": "2024-08-10T16:39:30Z", - "timestamp": 1723307970861 - }, - "reference-count": 15, - "publisher": "The Open Journal", - "issue": "50", - "license": [ - { - "start": { - "date-parts": [ - [ - 2020, - 6, - 9 - ] - ], - "date-time": "2020-06-09T00:00:00Z", - "timestamp": 1591660800000 - }, - "content-version": "vor", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 6, - 9 - ] - ], - "date-time": "2020-06-09T00:00:00Z", - "timestamp": 1591660800000 - }, - "content-version": "am", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - }, - { - "start": { - "date-parts": [ - [ - 2020, - 6, - 9 - ] - ], - "date-time": "2020-06-09T00:00:00Z", - "timestamp": 1591660800000 - }, - "content-version": "tdm", - "delay-in-days": 0, - "URL": "http://creativecommons.org/licenses/by/4.0/" - } - ], - "content-domain": { - "domain": [], - "crossmark-restriction": false + "date-time": "2020-07-05T00:00:00Z", + "timestamp": 1593907200000 }, - "short-container-title": [ - "JOSS" - ], - "published-print": { + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { "date-parts": [ [ 2020, - 6, - 9 + 7, + 5 ] - ] + ], + "date-time": "2020-07-05T00:00:00Z", + "timestamp": 1593907200000 }, - "DOI": "10.21105/joss.02314", - "type": "journal-article", - "created": { + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { "date-parts": [ [ 2020, - 6, - 9 + 7, + 5 ] ], - "date-time": "2020-06-09T11:45:17Z", - "timestamp": 1591703117000 + "date-time": "2020-07-05T00:00:00Z", + "timestamp": 1593907200000 }, - "page": "2314", - "source": "Crossref", - "is-referenced-by-count": 29, - "title": [ - "pyrolite: Python for geochemistry" - ], - "prefix": "10.21105", - "volume": "5", - "author": [ - { - "ORCID": "http://orcid.org/0000-0003-4764-9555", - "authenticated-orcid": false, - "given": "Morgan", - "family": "Williams", - "sequence": "first", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-9324-1676", - "authenticated-orcid": false, - "given": "Louise", - "family": "Schoneveld", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-2725-2158", - "authenticated-orcid": false, - "given": "Yajing", - "family": "Mao", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0001-5911-6022", - "authenticated-orcid": false, - "given": "Jens", - "family": "Klump", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-5351-7295", - "authenticated-orcid": false, - "given": "Justin", - "family": "Gosses", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-2114-9894", - "authenticated-orcid": false, - "given": "Hayden", - "family": "Dalton", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0003-0882-0807", - "authenticated-orcid": false, - "given": "Adam", - "family": "Bath", - "sequence": "additional", - "affiliation": [] - }, - { - "ORCID": "http://orcid.org/0000-0002-4912-9177", - "authenticated-orcid": false, - "given": "Steve", - "family": "Barnes", - "sequence": "additional", - "affiliation": [] - } - ], - "member": "8722", - "reference": [ - { - "key": "ref1", - "doi-asserted-by": "publisher", - "DOI": "10.1007/BF01029316" - }, - { - "key": "ref2", - "doi-asserted-by": "publisher", - "DOI": "10.1016/S0012-821X(03)00129-8" - }, - { - "key": "ref3", - "doi-asserted-by": "publisher", - "DOI": "10.1016/B978-0-08-095975-7.00203-5" - }, - { - "key": "ref4", - "doi-asserted-by": "publisher", - "DOI": "10.1109/MCSE.2007.55" - }, - { - "key": "ref5", - "doi-asserted-by": "publisher", - "DOI": "10.1007/BF01160698" - }, - { - "key": "ref6", - "doi-asserted-by": "publisher", - "DOI": "10.2113/gsecongeo.104.3.405" - }, - { - "key": "ref7", - "unstructured": "Data Structures for Statistical Computing in Python, Proceedings of the 9th Python in Science Conference, McKinney, Wes, van der Walt, St\u00e9fan and Millman, Jarrod, 2010, 51\u201356" - }, - { - "key": "ref8", - "doi-asserted-by": "publisher", - "DOI": "10.1093/petrology/egw047" - }, - { - "key": "ref9", - "doi-asserted-by": "publisher", - "DOI": "10.1016/B978-0-08-095975-7.00201-1" - }, - { - "key": "ref10", - "doi-asserted-by": "publisher", - "DOI": "10.1016/j.lithos.2007.06.016" - }, - { - "key": "ref11", - "doi-asserted-by": "publisher", - "DOI": "10.1098/rspl.1896.0076" - }, - { - "key": "ref12", - "unstructured": "Scikit-Learn: Machine Learning in Python, Scikit-Learn, Pedregosa, Fabian and Varoquaux, Ga\u00ebl and Gramfort, Alexandre and Michel, Vincent and Thirion, Bertrand and Grisel, Olivier and Blondel, Mathieu and Prettenhofer, Peter and Weiss, Ron and Dubourg, Vincent and Vanderplas, Jake and Passos, Alexandre and Cournapeau, David and Brucher, Matthieu and Perrot, Matthieu and Duchesnay, \u00c9douard, 2011, oct, 12, 2825-2830, 1533-7928, Scikit-learn is a Python module integrating a wide range of state-of-the-art machine learning algorithms for medium-scale supervised and unsupervised problems. This package focuses on bringing machine learning to non-specialists using a general-purpose high-level language. Emphasis is put on ease of use, performance, documentation, and API consistency. It has minimal dependencies and is distributed under the simplified BSD license, encouraging its use in both academic and commercial settings. Source code, binaries, and documentation can be downloaded from http://scikit-learn.sourceforge.net., Journal of Machine Learning Research, 10" - }, - { - "key": "ref13", - "doi-asserted-by": "publisher", - "DOI": "10.1029/2004GC000816" - }, - { - "key": "ref14", - "doi-asserted-by": "publisher", - "DOI": "10.1144/GSL.SP.1989.042.01.19" - }, - { - "key": "ref15", - "doi-asserted-by": "publisher", - "DOI": "10.18637/jss.v059.i10" - } - ], - "container-title": [ - "Journal of Open Source Software" - ], - "link": [ - { - "URL": "http://www.theoj.org/joss-papers/joss.02314/10.21105.joss.02314.pdf", - "content-type": "application/pdf", - "content-version": "vor", - "intended-application": "text-mining" - } - ], - "deposited": { + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 7, + 5 + ] + ] + }, + "DOI": "10.21105/joss.02284", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 7, + 5 + ] + ], + "date-time": "2020-07-05T19:51:15Z", + "timestamp": 1593978675000 + }, + "page": "2284", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "GridTest: testing and metrics collection for Python" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-4387-3819", + "authenticated-orcid": false, + "given": "Vanessa", + "family": "Sochat", + "sequence": "first", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "unstructured": "GridTest on GitHub, GridTest, https://github.com/vsoch/gridtest, 2020, ://github.com/vsoch/gridtest/, Accessed: 2020-05-14" + }, + { + "key": "ref2", + "unstructured": "GridTest, GridTest Documentation, https://vsoch.github.io/gridtest/, 2020, ://vsoch.github.io/gridtest, Accessed: 2020-05-14" + }, + { + "key": "ref3", + "unstructured": "Scientific Software Testing: A Practical Example, Koteska, Bojana and Pejov, Ljupco and Mishev, Anastas, SQAMIA, 2015" + }, + { + "key": "ref4", + "unstructured": "sklearn.model_selection.ParameterGrid \u2014 scikit-learn 0.23.1 documentation, scikit-learn: machine learning in Python, ://scikit-learn.org/stable/modules/generated/sklearn.model_selection.ParameterGrid.html, Accessed: 2020-6-30, 2020" + }, + { + "key": "ref5", + "unstructured": "Scikit-learn: Machine Learning in Python, Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V. and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P. and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E., Journal of Machine Learning Research, 12, 2825\u20132830, 2011" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.1107/S2059798320003198" + }, + { + "key": "ref7", + "unstructured": "Keras, Chollet, Francois and others, 2015, GitHub, https://github.com/fchollet/keras" + }, + { + "key": "ref8", + "unstructured": "Grid (Hyperparameter) Search \u2014 H2O 3.30.0.5 documentation, ://docs.h2o.ai/h2o/latest-stable/h2o-docs/grid-search.html, Accessed: 2020-6-20, 2020" + }, + { + "key": "ref9", + "unstructured": "Intro to Model Tuning: Grid and Random Search, Kaggle, Koehrsen, W., Explore and run machine learning code with Kaggle Notebooks | Using data from multiple data sources, jul, 2018, ://kaggle.com/willkoehrsen/intro-to-model-tuning-grid-and-random-search, Accessed: 2020-6-20, 7" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.02284/10.21105.joss.02284.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 7, + 5 + ] + ], + "date-time": "2020-07-05T19:51:20Z", + "timestamp": 1593978680000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02284" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 7, + 5 + ] + ] + }, + "references-count": 9, + "journal-issue": { + "issue": "51", + "published-online": { + "date-parts": [ + [ + 2020, + 7 + ] + ] + } + }, + "alternative-id": [ + "10.21105/joss.02284" + ], + "URL": "http://dx.doi.org/10.21105/joss.02284", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3930366\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2284", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 7, + 5 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 4, + 4 + ] + ], + "date-time": "2022-04-04T20:55:20Z", + "timestamp": 1649105720985 + }, + "reference-count": 5, + "publisher": "The Open Journal", + "issue": "48", + "license": [ + { + "start": { "date-parts": [ [ 2020, - 6, - 9 + 4, + 13 ] ], - "date-time": "2020-06-09T11:45:29Z", - "timestamp": 1591703129000 + "date-time": "2020-04-13T00:00:00Z", + "timestamp": 1586736000000 }, - "score": 0.0, - "resource": { - "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.02314" - } + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ], + "date-time": "2020-04-13T00:00:00Z", + "timestamp": 1586736000000 }, - "issued": { + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { "date-parts": [ [ 2020, - 6, - 9 + 4, + 13 ] - ] + ], + "date-time": "2020-04-13T00:00:00Z", + "timestamp": 1586736000000 }, - "references-count": 15, - "journal-issue": { - "issue": "50", - "published-online": { - "date-parts": [ - [ - 2020, - 6 - ] + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ] + }, + "DOI": "10.21105/joss.02145", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ], + "date-time": "2020-04-13T12:09:48Z", + "timestamp": 1586779788000 + }, + "page": "2145", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": "Visions: An Open-Source Library for Semantic Data", + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0001-9866-7767", + "authenticated-orcid": false, + "given": "Simon", + "family": "Brugman", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0001-6788-8188", + "authenticated-orcid": false, + "given": "Ian", + "family": "Eaves", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.5281/zenodo.3644238" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.1109/MCSE.2011.37" + }, + { + "key": "ref3", + "unstructured": "Hagberg, Aric A. and Schult, Daniel A. and Swart, Pieter J., Exploring Network Structure, Dynamics, and Function using NetworkX, Proceedings of the 7th Python in Science Conference, 11 - 15, Pasadena, CA USA, 2008, Varoquaux, Ga\u00ebl and Vaught, Travis and Millman, Jarrod" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.5281/zenodo.3545747" + }, + { + "key": "ref5", + "unstructured": "Brugman, Simon, pandas-profiling: exploratory data analysis reports in Python, 2020, https://github.com/pandas-profiling/pandas-profiling, Version: 2.4.0, Accessed: 01/02/2020" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.02145/10.21105.joss.02145.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ], + "date-time": "2020-04-13T12:09:55Z", + "timestamp": 1586779795000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02145" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ] + }, + "references-count": 5, + "journal-issue": { + "issue": "48", + "published-online": { + "date-parts": [ + [ + 2020, + 4 + ] + ] + } + }, + "alternative-id": [ + "10.21105/joss.02145" + ], + "URL": "http://dx.doi.org/10.21105/joss.02145", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3748758\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2145", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 4, + 13 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2024, + 9, + 12 + ] + ], + "date-time": "2024-09-12T13:53:46Z", + "timestamp": 1726149226135 + }, + "reference-count": 9, + "publisher": "The Open Journal", + "issue": "46", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 2, + 6 ] - } + ], + "date-time": "2020-02-06T00:00:00Z", + "timestamp": 1580947200000 }, - "alternative-id": [ - "10.21105/joss.02314" - ], - "URL": "http://dx.doi.org/10.21105/joss.02314", - "relation": { - "references": [ - { - "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3877690\u201d", - "asserted-by": "subject" - } + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] ], - "has-review": [ - { - "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/2314", - "asserted-by": "subject" - } - ] + "date-time": "2020-02-06T00:00:00Z", + "timestamp": 1580947200000 }, - "ISSN": [ - "2475-9066" - ], - "issn-type": [ - { - "value": "2475-9066", - "type": "electronic" - } - ], - "published": { + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { "date-parts": [ [ 2020, - 6, - 9 + 2, + 6 ] + ], + "date-time": "2020-02-06T00:00:00Z", + "timestamp": 1580947200000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] + ] + }, + "DOI": "10.21105/joss.02071", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] + ], + "date-time": "2020-02-06T16:11:05Z", + "timestamp": 1581005465000 + }, + "page": "2071", + "source": "Crossref", + "is-referenced-by-count": 14, + "title": [ + "osfr: An R Interface to the Open Science Framework" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0003-2542-2202", + "authenticated-orcid": false, + "given": "Aaron", + "family": "Wolen", + "sequence": "first", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-1050-6809", + "authenticated-orcid": false, + "given": "Chris", + "family": "Hartgerink", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Ryan", + "family": "Hafen", + "sequence": "additional", + "affiliation": [] + }, + { + "given": "Brian", + "family": "Richards", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-1227-7042", + "authenticated-orcid": false, + "given": "Courtney", + "family": "Soderberg", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-4068-4286", + "authenticated-orcid": false, + "given": "Timothy", + "family": "York", + "sequence": "additional", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "unstructured": "crul: HTTP Client, Chamberlain, Scott, 2019, R package version 0.9.0, https://CRAN.R-project.org/package=crul" + }, + { + "key": "ref2", + "unstructured": "googledrive: An Interface to Google Drive, D\u2019Agostino McGowan, Lucy and Bryan, Jennifer, 2019, R package version 1.0.0, https://cran.r-project.org/package=googledrive" + }, + { + "key": "ref3", + "unstructured": "magrittr: A Forward-Pipe Operator for R, Bache, Stefan Milton and Wickham, Hadley, 2014, R package version 1.5, https://CRAN.R-project.org/package=magrittr" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1186/1751-0473-8-7" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1371/journal.pcbi.1003285" + }, + { + "key": "ref6", + "unstructured": "tibble: Simple Data Frames, M\u00fcller, Kirill and Wickham, Hadley, 2019, R package version 2.1.3, https://CRAN.R-project.org/package=tibble" + }, + { + "key": "ref7", + "unstructured": "stringr: Simple, Consistent Wrappers for Common String Operations, Wickham, Hadley, 2019, R package version 1.4.0, https://cran.r-project.org/package=stringr" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1002/cpet.32" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1371/journal.pcbi.1005510" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.02071/10.21105.joss.02071.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] + ], + "date-time": "2020-02-06T16:11:09Z", + "timestamp": 1581005469000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.02071" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] + ] + }, + "references-count": 9, + "journal-issue": { + "issue": "46", + "published-online": { + "date-parts": [ + [ + 2020, + 2 ] + ] + } + }, + "alternative-id": [ + "10.21105/joss.02071" + ], + "URL": "http://dx.doi.org/10.21105/joss.02071", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3625248\u201d", + "asserted-by": "subject" } - }, - { + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/2071", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 2, + 6 + ] + ] + } + }, + { "indexed": { "date-parts": [ [ - 2022, - 3, - 29 + 2024, + 8, + 10 ] ], - "date-time": "2022-03-29T18:07:01Z", - "timestamp": 1648577221171 + "date-time": "2024-08-10T16:39:30Z", + "timestamp": 1723307970861 }, - "reference-count": 4, + "reference-count": 15, "publisher": "The Open Journal", - "issue": "48", + "issue": "50", "license": [ { "start": { "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ], - "date-time": "2020-04-03T00:00:00Z", - "timestamp": 1585872000000 + "date-time": "2020-06-09T00:00:00Z", + "timestamp": 1591660800000 }, "content-version": "vor", "delay-in-days": 0, @@ -4858,12 +4522,12 @@ "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ], - "date-time": "2020-04-03T00:00:00Z", - "timestamp": 1585872000000 + "date-time": "2020-06-09T00:00:00Z", + "timestamp": 1591660800000 }, "content-version": "am", "delay-in-days": 0, @@ -4874,12 +4538,12 @@ "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ], - "date-time": "2020-04-03T00:00:00Z", - "timestamp": 1585872000000 + "date-time": "2020-06-09T00:00:00Z", + "timestamp": 1591660800000 }, "content-version": "tdm", "delay-in-days": 0, @@ -4897,40 +4561,96 @@ "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ] }, - "DOI": "10.21105/joss.01843", + "DOI": "10.21105/joss.02314", "type": "journal-article", "created": { "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ], - "date-time": "2020-04-03T12:49:42Z", - "timestamp": 1585918182000 + "date-time": "2020-06-09T11:45:17Z", + "timestamp": 1591703117000 }, - "page": "1843", + "page": "2314", "source": "Crossref", - "is-referenced-by-count": 0, + "is-referenced-by-count": 29, "title": [ - "JCOL: A Java package for solving the graph coloring problem" + "pyrolite: Python for geochemistry" ], "prefix": "10.21105", "volume": "5", "author": [ { - "ORCID": "http://orcid.org/0000-0002-3770-1391", + "ORCID": "http://orcid.org/0000-0003-4764-9555", "authenticated-orcid": false, - "given": "Shalin", - "family": "Shah", + "given": "Morgan", + "family": "Williams", "sequence": "first", "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-9324-1676", + "authenticated-orcid": false, + "given": "Louise", + "family": "Schoneveld", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-2725-2158", + "authenticated-orcid": false, + "given": "Yajing", + "family": "Mao", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0001-5911-6022", + "authenticated-orcid": false, + "given": "Jens", + "family": "Klump", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-5351-7295", + "authenticated-orcid": false, + "given": "Justin", + "family": "Gosses", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-2114-9894", + "authenticated-orcid": false, + "given": "Hayden", + "family": "Dalton", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0003-0882-0807", + "authenticated-orcid": false, + "given": "Adam", + "family": "Bath", + "sequence": "additional", + "affiliation": [] + }, + { + "ORCID": "http://orcid.org/0000-0002-4912-9177", + "authenticated-orcid": false, + "given": "Steve", + "family": "Barnes", + "sequence": "additional", + "affiliation": [] } ], "member": "8722", @@ -4938,22 +4658,75 @@ { "key": "ref1", "doi-asserted-by": "publisher", - "DOI": "10.1145/359094.359101" + "DOI": "10.1007/BF01029316" }, { "key": "ref2", "doi-asserted-by": "publisher", - "DOI": "10.7939/R3M32NH6Q" + "DOI": "10.1016/S0012-821X(03)00129-8" }, { "key": "ref3", "doi-asserted-by": "publisher", - "DOI": "10.1111/j.1475-3995.2009.00696.x" + "DOI": "10.1016/B978-0-08-095975-7.00203-5" }, { "key": "ref4", "doi-asserted-by": "publisher", - "DOI": "10.1145/2513109.2513110" + "DOI": "10.1109/MCSE.2007.55" + }, + { + "key": "ref5", + "doi-asserted-by": "publisher", + "DOI": "10.1007/BF01160698" + }, + { + "key": "ref6", + "doi-asserted-by": "publisher", + "DOI": "10.2113/gsecongeo.104.3.405" + }, + { + "key": "ref7", + "unstructured": "Data Structures for Statistical Computing in Python, Proceedings of the 9th Python in Science Conference, McKinney, Wes, van der Walt, St\u00e9fan and Millman, Jarrod, 2010, 51\u201356" + }, + { + "key": "ref8", + "doi-asserted-by": "publisher", + "DOI": "10.1093/petrology/egw047" + }, + { + "key": "ref9", + "doi-asserted-by": "publisher", + "DOI": "10.1016/B978-0-08-095975-7.00201-1" + }, + { + "key": "ref10", + "doi-asserted-by": "publisher", + "DOI": "10.1016/j.lithos.2007.06.016" + }, + { + "key": "ref11", + "doi-asserted-by": "publisher", + "DOI": "10.1098/rspl.1896.0076" + }, + { + "key": "ref12", + "unstructured": "Scikit-Learn: Machine Learning in Python, Scikit-Learn, Pedregosa, Fabian and Varoquaux, Ga\u00ebl and Gramfort, Alexandre and Michel, Vincent and Thirion, Bertrand and Grisel, Olivier and Blondel, Mathieu and Prettenhofer, Peter and Weiss, Ron and Dubourg, Vincent and Vanderplas, Jake and Passos, Alexandre and Cournapeau, David and Brucher, Matthieu and Perrot, Matthieu and Duchesnay, \u00c9douard, 2011, oct, 12, 2825-2830, 1533-7928, Scikit-learn is a Python module integrating a wide range of state-of-the-art machine learning algorithms for medium-scale supervised and unsupervised problems. This package focuses on bringing machine learning to non-specialists using a general-purpose high-level language. Emphasis is put on ease of use, performance, documentation, and API consistency. It has minimal dependencies and is distributed under the simplified BSD license, encouraging its use in both academic and commercial settings. Source code, binaries, and documentation can be downloaded from http://scikit-learn.sourceforge.net., Journal of Machine Learning Research, 10" + }, + { + "key": "ref13", + "doi-asserted-by": "publisher", + "DOI": "10.1029/2004GC000816" + }, + { + "key": "ref14", + "doi-asserted-by": "publisher", + "DOI": "10.1144/GSL.SP.1989.042.01.19" + }, + { + "key": "ref15", + "doi-asserted-by": "publisher", + "DOI": "10.18637/jss.v059.i10" } ], "container-title": [ @@ -4961,7 +4734,7 @@ ], "link": [ { - "URL": "http://www.theoj.org/joss-papers/joss.01843/10.21105.joss.01843.pdf", + "URL": "http://www.theoj.org/joss-papers/joss.02314/10.21105.joss.02314.pdf", "content-type": "application/pdf", "content-version": "vor", "intended-application": "text-mining" @@ -4971,56 +4744,56 @@ "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ], - "date-time": "2020-04-03T12:49:44Z", - "timestamp": 1585918184000 + "date-time": "2020-06-09T11:45:29Z", + "timestamp": 1591703129000 }, "score": 0.0, "resource": { "primary": { - "URL": "https://joss.theoj.org/papers/10.21105/joss.01843" + "URL": "https://joss.theoj.org/papers/10.21105/joss.02314" } }, "issued": { "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 ] ] }, - "references-count": 4, + "references-count": 15, "journal-issue": { - "issue": "48", + "issue": "50", "published-online": { "date-parts": [ [ 2020, - 4 + 6 ] ] } }, "alternative-id": [ - "10.21105/joss.01843" + "10.21105/joss.02314" ], - "URL": "http://dx.doi.org/10.21105/joss.01843", + "URL": "http://dx.doi.org/10.21105/joss.02314", "relation": { "references": [ { "id-type": "doi", - "id": "\u201chttps://doi.org/10.5281/zenodo.3709625\u201d", + "id": "\u201chttps://doi.org/10.5281/zenodo.3877690\u201d", "asserted-by": "subject" } ], "has-review": [ { "id-type": "uri", - "id": "https://github.com/openjournals/joss-reviews/issues/1843", + "id": "https://github.com/openjournals/joss-reviews/issues/2314", "asserted-by": "subject" } ] @@ -5038,10 +4811,233 @@ "date-parts": [ [ 2020, - 4, - 3 + 6, + 9 + ] + ] + } + }, + { + "indexed": { + "date-parts": [ + [ + 2022, + 3, + 29 + ] + ], + "date-time": "2022-03-29T18:07:01Z", + "timestamp": 1648577221171 + }, + "reference-count": 4, + "publisher": "The Open Journal", + "issue": "48", + "license": [ + { + "start": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ], + "date-time": "2020-04-03T00:00:00Z", + "timestamp": 1585872000000 + }, + "content-version": "vor", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ], + "date-time": "2020-04-03T00:00:00Z", + "timestamp": 1585872000000 + }, + "content-version": "am", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + }, + { + "start": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ], + "date-time": "2020-04-03T00:00:00Z", + "timestamp": 1585872000000 + }, + "content-version": "tdm", + "delay-in-days": 0, + "URL": "http://creativecommons.org/licenses/by/4.0/" + } + ], + "content-domain": { + "domain": [], + "crossmark-restriction": false + }, + "short-container-title": [ + "JOSS" + ], + "published-print": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ] + }, + "DOI": "10.21105/joss.01843", + "type": "journal-article", + "created": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ], + "date-time": "2020-04-03T12:49:42Z", + "timestamp": 1585918182000 + }, + "page": "1843", + "source": "Crossref", + "is-referenced-by-count": 0, + "title": [ + "JCOL: A Java package for solving the graph coloring problem" + ], + "prefix": "10.21105", + "volume": "5", + "author": [ + { + "ORCID": "http://orcid.org/0000-0002-3770-1391", + "authenticated-orcid": false, + "given": "Shalin", + "family": "Shah", + "sequence": "first", + "affiliation": [] + } + ], + "member": "8722", + "reference": [ + { + "key": "ref1", + "doi-asserted-by": "publisher", + "DOI": "10.1145/359094.359101" + }, + { + "key": "ref2", + "doi-asserted-by": "publisher", + "DOI": "10.7939/R3M32NH6Q" + }, + { + "key": "ref3", + "doi-asserted-by": "publisher", + "DOI": "10.1111/j.1475-3995.2009.00696.x" + }, + { + "key": "ref4", + "doi-asserted-by": "publisher", + "DOI": "10.1145/2513109.2513110" + } + ], + "container-title": [ + "Journal of Open Source Software" + ], + "link": [ + { + "URL": "http://www.theoj.org/joss-papers/joss.01843/10.21105.joss.01843.pdf", + "content-type": "application/pdf", + "content-version": "vor", + "intended-application": "text-mining" + } + ], + "deposited": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ], + "date-time": "2020-04-03T12:49:44Z", + "timestamp": 1585918184000 + }, + "score": 0.0, + "resource": { + "primary": { + "URL": "https://joss.theoj.org/papers/10.21105/joss.01843" + } + }, + "issued": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ] + }, + "references-count": 4, + "journal-issue": { + "issue": "48", + "published-online": { + "date-parts": [ + [ + 2020, + 4 ] ] } + }, + "alternative-id": [ + "10.21105/joss.01843" + ], + "URL": "http://dx.doi.org/10.21105/joss.01843", + "relation": { + "references": [ + { + "id-type": "doi", + "id": "\u201chttps://doi.org/10.5281/zenodo.3709625\u201d", + "asserted-by": "subject" + } + ], + "has-review": [ + { + "id-type": "uri", + "id": "https://github.com/openjournals/joss-reviews/issues/1843", + "asserted-by": "subject" + } + ] + }, + "ISSN": [ + "2475-9066" + ], + "issn-type": [ + { + "value": "2475-9066", + "type": "electronic" + } + ], + "published": { + "date-parts": [ + [ + 2020, + 4, + 3 + ] + ] } + } ] \ No newline at end of file diff --git a/clean-modular-code/checks-conditionals/python-function-checks.md b/clean-modular-code/checks-conditionals/python-function-checks.md new file mode 100644 index 0000000..ebd8668 --- /dev/null +++ b/clean-modular-code/checks-conditionals/python-function-checks.md @@ -0,0 +1,100 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.16.4 +kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +# Write Flexible Functions to Handle Messy Data + +When dealing with messy or unpredictable data, using functions is an excellent first step in creating a robust and maintainable data processing workflow. Functions provide modular units that can be tested independently, allowing you to handle various edge cases and unexpected scenarios effectively. + +## Function benefits + +Using functions in your data processing pipeline offers several advantages: + +1. **Modularity**: Functions encapsulate specific tasks, making your code more organized and easier to understand. +2. **Testability**: You can test functions individually, outside of the main workflow, to ensure they handle different scenarios correctly. +3. **Flexibility**: As you build out your workflow, you can easily add elements to functions to handle new processing requirements or edge cases. +4. **Reusability**: Well-designed functions can be reused across different parts of your project or even in other projects. + +## Handling edge cases + +When working with messy data, you'll often encounter edge cases - unusual or unexpected data that can break your processing pipeline. Functions allow you to implement robust error handling and data validation. Here are some techniques you can use: + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +## Try/Except blocks +Try/except blocks allow you to catch and handle exceptions that might occur during data processing. This is particularly useful when dealing with operations that might fail, such as type conversions or accessing nested data structures. + +```{code-cell} ipython3 +def safe_convert_to_int(value): + try: + return int(value) + except ValueError: + return None # or some default value + +# Example usage +result = safe_convert_to_int("123") # Returns 123 +result = safe_convert_to_int("abc") # Returns None +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +This function attempts to convert a value to an integer, returning None if the conversion fails. + +## Make checks Pythonic + +Python has a unique philosophy regarding handling potential errors or exceptional cases. This philosophy is often summarized by the acronym EAFP: "Easier to Ask for Forgiveness than Permission." + +### EAFP vs LBYL + +There are two main approaches to handling potential errors: + +LBYL (Look Before You Leap): Check for conditions before making calls or accessing data. +EAFP (Easier to Ask for Forgiveness than Permission): Assume the operation will succeed and handle any exceptions if they occur. + +Python generally favors the EAFP approach, which often leads to cleaner and more readable code. Here's an example to illustrate the difference: + +```{code-cell} ipython3 +# LBYL approach +def get_value_lbyl(dictionary, key, default=None): + if key in dictionary: + return dictionary[key] + else: + return default + +# EAFP approach +def get_value_eafp(dictionary, key, default=None): + try: + return dictionary[key] + except KeyError: + return default + +# Example usage +my_dict = {"a": 1, "b": 2} +print(get_value_lbyl(my_dict, "c", 0)) # Returns 0 +print(get_value_eafp(my_dict, "c", 0)) # Returns 0 +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +The EAFP approach is considered more Pythonic because: + +It's often faster, as it avoids redundant checks in the common case where the operation succeeds. +It's more readable and expressive, clearly showing the intended operation and the exception handling separately. +It helps avoid race conditions in certain scenarios, particularly in multi-threaded environments. + +## Any check is a good check + +Ultimately, as long as you are considering the various edge cases your code may encounter when creating functions, you are writing great code! You don't have to worry about being Pythonic. + +However, it's good to understand the value of both approaches and to get in the habit of writing Pythonic code sooner rather than later as a good practice! diff --git a/clean-modular-code/intro-clean-code.md b/clean-modular-code/intro-clean-code.md index 7fd4f0e..b2a9d7b 100644 --- a/clean-modular-code/intro-clean-code.md +++ b/clean-modular-code/intro-clean-code.md @@ -51,8 +51,8 @@ Tests & Checks :maxdepth: 2 Clean Code: Activity 1 -Clean Code: Activity 2 -Clean Code: Activity 3 +Clean Code: Activity 2 +Clean Code: Activity 3 ::: :::{note} @@ -205,7 +205,7 @@ however, it's important that you are careful about how you use them because * they are often wrong * they make up stuff * etc. -however with correct promots, and if you build your eye for identifying problems, and combined with tools that will help you with your code, as you write it, they can be effective tools in your workfhlow dev process. +however with correct prompts, and if you build your eye for identifying problems, and combined with tools that will help you with your code, as you write it, they can be effective tools in your workflow dev process. In the next lessons, you will learn more about making tools and approaches to making your code more Pythonic From 3eb989274e66f8fc5d9c10530fef4afd9fef324a Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Wed, 9 Oct 2024 13:37:24 -0600 Subject: [PATCH 7/9] fix: rebase files from main --- clean-modular-code/pep8-package-imports.md | 79 +++++ clean-modular-code/python-pep-8.md | 356 +++++++++------------ 2 files changed, 236 insertions(+), 199 deletions(-) create mode 100644 clean-modular-code/pep8-package-imports.md diff --git a/clean-modular-code/pep8-package-imports.md b/clean-modular-code/pep8-package-imports.md new file mode 100644 index 0000000..5807ba7 --- /dev/null +++ b/clean-modular-code/pep8-package-imports.md @@ -0,0 +1,79 @@ +--- +jupytext: + text_representation: + extension: .md + format_name: myst + format_version: 0.13 + jupytext_version: 1.16.4 +kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +# Best Practices for Importing Python Packages In Scientific Code + +There are a set of best practices that you should follow when importing **Python** packages in your code. These best practices are outlined in the PEP 8 guidelines and apply to both **Python** scripts and to working in **Jupyter Notebook** files. + +## Import Python Libraries at the Top of Your Script or Notebook + +It is good practice to import all of the packages that you will need at the top of your **Python** script (.py file) or in the first code cell of a **Jupyter Notebook** file. + +This allows anyone looking at your code to immediately know what packages they need to have installed in order to successfully run the code. This rule also follows the PEP 8 conventions for **Python** code. + +```python +import os + +import pandas as pd +import numpy as np +``` + +Once you have imported all of the packages that you need to run your code in a script, you have access to all of the functions and classes defined in each package. + +If these imports are at the top of the script or **Jupyter Notebook** file, then you will be able to use those packages in any code lines that follow. + +This means that if you import a package *after* running some code that requires that package, your code will not run successfully. + + +## 2. List Package Imports Following PEP 8 Standards: Most Common First, Followed By Third Party + +PEP 8 also specifies the order in which you should list your imports as follows (starting with the most commonly used): + +> Imports should be grouped in the following order: +> Standard library imports. +> Related third party imports. +> Local application/library specific imports. +> You should put a blank line between each group of imports. + +You may be wondering, what is a standard library import? The standard library imports are commonly used tools that are general in purpose and are part of the standard library of **Python**. These including things like: + +* **os**: handle files and directories. +* **glob**: create lists of files and directories for batch processing. + +In the PEP 8 order, other commonly used packages that are general in purpose will follow such as: + +* **numpy**: work with data in array formats. +* **matplotlib**: plot data. +* * **Pandas**: to work with tabular data. + +A PEP 8 order of imports for commonly used **Python** packages for science would look something like this: + +```python +import os +import glob + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +``` + +Note that there is a space between the standard imports (`glob` and `os`) +and the rest of the third-party imports. + +## What are Local application/library specific imports + +Local application / library specific imports refer to tool that you have created locally or just for your own work. + +TODO: more here... diff --git a/clean-modular-code/python-pep-8.md b/clean-modular-code/python-pep-8.md index aa469f4..e5a8a68 100644 --- a/clean-modular-code/python-pep-8.md +++ b/clean-modular-code/python-pep-8.md @@ -14,218 +14,207 @@ kernelspec: +++ {"editable": true, "slideshow": {"slide_type": ""}} -# Python code style for readability and usability +# Use PEP 8 To Write Easier-to-Read Code -:::{admonition} What you will learn +:::{admonition} Learning Objectives :class: tip -* How to follow the PEP 8 style guide to write Python code that’s easy to read and understand. -* Best practices for naming variables, using comments, and formatting code. -* Tools to help you apply PEP 8 to your code automatically. +* Describe the benefits of using code standards. +* Explain the PEP 8 style guide and how it helps promote code readability. +* Describe key components of the PEP 8 style guide, including naming conventions and white space. +* List tools to help you apply the PEP 8 style guide to your code. ::: -## Why code style and Python PEP 8 matters +## What is Python PEP 8 code style? -Just like good grammar makes text easier to read, PEP 8 helps make your code easier to understand. It enforces rules on naming variables, capitalization, formatting code, and structuring your script. Well-formatted code also makes it easier for you to share code, given it will be easier for others to understand. +Code syntax standards refer to rules associated with how code is formatted. These rules can including things like: -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' ---- -#some data analysis with poor formatting -import pandas as pd -from datetime import datetime -def classify_precipitation(precip_list): - avg_precip=pd.Series(precip_list).mean() - if avg_precip<100: - return'Low' - elif avg_precip>=100 and avg_precip<=150: - return'Medium' - else: - return'High' -data={'location':['Station1','Station2','Station3','Station4'],'year':[2021,2021,2021,2021],'monthly_precipitation':[[50.0,70.0,90.0,80.0],[100.0,110.0,120.0,130.0],[150.0,160.0,170.0,180.0],[200.0,210.0,220.0,230.0]],'start_date':["2021-01-01","2021-01-01","2021-01-01","2021-01-01"]} -df=pd.DataFrame(data) -df['start_date']=pd.to_datetime(df['start_date']) -df['precipitation_category']=df['monthly_precipitation'].apply(classify_precipitation) -df -``` +* How to space code elements in a script, +* How to format and create comments, and +* Naming conventions for variables, functions and classes -+++ {"editable": true, "slideshow": {"slide_type": ""}} +## Why Use Code Standards When Writing Python Code -Notice that by adding docstrings, spacing to the the code.... +Code standards help make your code more readable. Consider this page that you are reading right now. Some conventions are followed that most of us are familiar with (but may not even think about). These conventions include: -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' ---- -# Built-in libraries are imported first -from datetime import datetime -import pandas as pd - -# Function to classify precipitation levels -def classify_precipitation(precip_list): - """Classify average monthly precipitation into low, medium, or high. - - Parameters - ---------- - precip_list : list of float - A list of monthly precipitation values (in mm). - - Returns - ------- - str - The precipitation category: 'Low', 'Medium', or 'High'. - """ - avg_precip = pd.Series(precip_list).mean() - - # Define the precipitation ranges - if avg_precip < 100: - return 'Low' - elif 100 <= avg_precip <= 150: - return 'Medium' - else: - return 'High' - - -# Sample data for precipitation values (in mm) for different locations -data = { - 'location': ['Station1', 'Station2', 'Station3', 'Station4'], - 'year': [2021, 2021, 2021, 2021], - 'monthly_precipitation': [ - [50.0, 70.0, 90.0, 80.0], # Station1 - [100.0, 110.0, 120.0, 130.0], # Station2 - [150.0, 160.0, 170.0, 180.0], # Station3 - [200.0, 210.0, 220.0, 230.0] # Station4 - ], - 'start_date': ["2021-01-01", "2021-01-01", "2021-01-01", "2021-01-01"] -} - -df = pd.DataFrame(data) -df['start_date'] = pd.to_datetime(df['start_date']) - -# Classify precipitation levels based on ranges -df['precipitation_category'] = df['monthly_precipitation'].apply(classify_precipitation) - -df -``` +* Capitalize the first letter of a sentence. +* Capitalize the first letter of someone's name. +* Add a space after the end of a sentence. +* Add a space after each word. -+++ {"editable": true, "slideshow": {"slide_type": ""}} +These conventions lead to text that you can read easily, like this: -## How to Apply PEP 8 Code Style Standards +`This is a sentence. And another sentence with a Name and a location like Florida, USA.` -It may seem overwhelming to remember all the PEP 8 rules, but tools called **code formatters** can automatically apply these standards for you. +Now imagine reading a book that has no spacing, no capitalization and didn't follow the regular English language writing conventions that you know. This book would become increasingly hard to read. For example have a look at the example below: -### For `.py` Files +`this is a sentence.and another sentence with a name.this +text could go on forever. whatwouldhappenifweneverusedspaces?` -Use popular tools like **Black** or **Ruff**: +Code standards, just like any other language standard, are designed to make code easier to understand. -- **[Black](https://black.readthedocs.io/en/stable/)**: Automatically reformats code according to PEP 8. -- **[Ruff](https://docs.astral.sh/ruff/configuration/#jupyter-notebook-discovery)**: A linter and formatter that also supports import sorting with **isort**. +Below, you will learn about the PEP 8 standard for the **Python** scientific programming language. This is the standard used by many **Python** users. -Both tools can be run manually or integrated into **pre-commit hooks** with Git to check your code before each commit. You can also configure them in your IDE (like VSCode, PyCharm, or Spyder) to format your code every time you save. +## About the PEP 8 Standard for Python +PEP 8 is the style guide that is widely used in the **Python** community. This guide includes rules about naming objects, spacing rules and even how the code is laid out. -:::{note} -Ruff doesn’t fully support Jupyter/MyST markdown notebooks yet but can be integrated into a pre-commit workflow for GitHub repositories. -::: +**Python** is developed and maintained by an open source community, and thus, it is not really possible to enforce the standard in mandatory way. Rather, community members choose to adhere to PEP 8 recommendations whenever possible, so that they can contribute code that can easily be read and used by the greater community of users. + +PEP 8 covers many aspects of code readability including: + +* naming conventions +* use of comments +* line lengths +* use of white space +## PEP 8 Naming Conventions -### For Jupyter Notebooks +The text in this section is summarized from the PEP 8 Style Guide published by the Python Software Foundation. -For Jupyter Notebooks, try: -- **Notebook extensions**: Add extensions to your interface to format cells automatically. -- **nbQA**: A command-line tool that applies Black or Ruff to Jupyter Notebooks via the CLI. +### Naming Convention Terminology Review -### Running These Tools -These tools can be used in the following ways: -- **Manually**: Run on-demand to check and format your code. -- **Pre-commit hook**: Enforce code style checks before every commit. -- **IDE integration**: Automatically format code in your editor. +First, let's review some terminology associated with naming conventions. -Using these tools ensures your code remains consistent, readable, and compliant with PEP 8, without memorizing all the rules. +* **Lowercase letter:** `b` -:::{admonition} Linter vs. Code Formatter -:class: note +* **Uppercase letter:** `B` -- **Linter**: Checks your code and highlights issues but doesn’t automatically fix them. -- **Code Formatter**: Automatically reformats your code according to style rules. +* **lowercase:** `this is all lowercase words` -Ruff acts as both a linter and formatter, making it ideal for `.py` file workflows. -::: +* **snake case:** when words are separated by underscores: `lower_case_with_underscores` -+++ {"editable": true, "slideshow": {"slide_type": ""}} +* **Uppercase:** All words are all uppercase letters: `UPPERCASE` + +* **Snake case** upper case: `UPPER_CASE_WITH_UNDERSCORES` + +* **CamelCase:** Every word is capitalized so they visually stand out: `CapitalizedWords`. This is sometimes also referred to as CapWords or StudlyCaps. + + * Note: When using acronyms in CamelCase, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError. + +* **mixedCase:** (differs from CapitalizedWords by initial lowercase character!) + +* **Capitalized_Words_With_Underscores:** This approach is not recommended. Use one convention and stick with it. + +### Name Variables Using snake_case And All Lower Case + +In general, it is recommended that you keep naming conventions standard in your code. We suggest a convention that uses **snake_case** and all lowercase letters in your code for variable and function names. + +``` +variable_one +variable_two +``` + +### Name Classes Using CamelCase or CapsCase + +While regular variables and functions should use snake_case, PEP 8 +suggests that you use `CamelCase` for class definitions. + +``` +class PlotBasicObject(object): +``` + +### Avoid Using Single Character Letters That Could Be Confused with Numbers + +Avoid using the characters: + +* 'l' (lowercase letter el), +* 'O' (uppercase letter oh), or +* 'I' (uppercase letter eye) + +as single character variable names. +These characters can be difficult to distinguish from numbers when +using certain font families. -## Why use code standards when writing Python code +For example, the letter `l` can sometimes look a lot like the number `1`. If you need to use the letter `l` as a variable (this is not suggested!), considering user an uppercase letter instead. -Code standards make your code more readable and easier to maintain, just like writing conventions make text easier to read. Think about how we capitalize the first word of a sentence or add spaces between words—without those conventions, text would be hard to follow. Similarly, code with inconsistent formatting is difficult to understand and debug. - -For example: +## Python PEP 8 Documentation Standards for Comments -* Readable sentence: This is a sentence. -* Unformatted sentence: thisisasentence.withoutspacesitgetsconfusing. +Documentation is an important part of writing great code. Below are some +of the important PEP 8 conventions associated with documentation. -Using code standards like PEP 8 helps avoid such confusion, making code clearer and more professional. +### 1. Python Comments Should Have a Space After the `#` Sign with the First Word Capitalized -### Some PEP 8 rules to remember +Following the PEP8 style guide, single line comments should +start with the `#` sign followed by a space. The first word of the comment should be capitalized. Like this: -There is a style guide devoted to Python pep 8 standards that you can read [here](https://www.python.org/dev/peps/pep-0008/#naming-conventions). However, below are a handful of PEP 8 Rules that you can consider following when writing code. +`# This is a PEP 8 conforming comment` + +The comment below does NOT conform to PEP8 standards + +`#this comment does not conform to PEP 8 standards` + +### 2. Multi-line comments Used in Functions (docstrings) Should Have a Short Single Line Description Followed By More Text + +Multi-line comments are most commonly used when creating docstrings. A docstring is the text that follows a function definition. This text helps you or someone using a function understand what the function does. + +Following the PEP8 style guide, you create a function docstring using three quotes `"""`. The first line or text following the quotes should be a short, concise description of what the function does. -* Naming Conventions: Use **snake_case** for variables/functions and **CamelCase** for class names. +Below that, you can add as much text as you'd like that provides more detail about what the function does. + +example: ```python -# This is a class definition -class MyClass: - """A class to process data and calculate statistics.""" - - # This is a function - def calculate_average(self, data_list): - """Calculate the average of a list of numbers.""" - total_sum = sum(data_list) - count = len(data_list) - return total_sum / count - -# Example variable names and function call -data_processor = DataProcessor() -numbers = [10, 20, 30, 40, 50] -average_value = data_processor.calculate_average(numbers) - -print(f"The average value is: {average_value}") +def calculate_sum(rainfall, time="month"): + +"""Returns a single sum value of all precipitation. + +This function takes a Pandas DataFrame with time series as the index, +and calculates the total sum, aggregated by month. +""" +# Code here + +return the_total_sum ``` -* Line Length: Limit all lines to 79 characters for better readability. +## Line Length + +PEP 8 guidelines suggest that each line of code (as well as comment lines) should be 79 characters wide or less. This is a common standard used in other languages, including **R**. :::{tip} Most text editors allow you to set up guides to see how long your code is. You can then use these guides to create line breaks in your code. ::: -* Comments: Add a space after the `#` sign and capitalize the first letter of a comment: -`# This is a PEP 8 conforming comment` +## Python PEP 8 Rules for White Space + +Some of the white space rules have already been discussed above. These including adding a single space after a comment `# Comment here`. + +There are also rules associated with spacing throughout your code. These include: -* White Space: Add space between sections of code to improve clarity. -* Avoid using single-character letters that could be confused with numbers (ie the letter `l` looks similar to the number one `1` -* Add a blank line before a single-line comment (unless it is the first line of a cell in Jupyter Notebook) +* **Add blank line before a single line comment (unless it is the first line of a cell in Jupyter Notebook)** Blank lines help to visually break up code. Consider reading this page, if all of the text was mashed together in one long paragraph, it would be more difficult to read. However, when you break the text up into related paragraphs, it becomes a lot easier to read. ```python -a = 1 -# Here is a commment -b = 2 +# Perform some math +a = 1+2 +b = 3+4 +c = a+b +# Read in and plot some +precip_timeseries = pd.readcsv("precip-2019.csv") +precip_timeseries.plot() ``` -* **Break up sections of code with white space:** Breaking up your +The code below is more difficult to read as the spacing does not break up the text. + +```python +# Perform some math and do some things +a=1+2 +b=3+4 +c=a+b +data=pd.readcsv("precip-2019.csv") +data.plot() +``` + +* **Break up sections of code with white space:** As you are writing code, it's always good to consider readability and to break up sections of code accordingly. Breaking up your code becomes even more important when you start working in Jupyter Notebooks which offer individual cells where you can add Markdown and code. ```python # Process some data here -data=pd.readcsv("pyos-data.csv") +data=pd.readcsv("precip-2019.csv") # Plot data - notice how separating code into sections makes it easier to read fig, ax = plot.subplots() @@ -233,60 +222,29 @@ data.plot(ax=ax) plt.show() ``` -## PEP 8 naming conventions +## Summary -- PEP 8 and Python -:::{seealso} -For the entire pep-8 style guide see: PEP 8 Style Guide published by the Python Software Foundation. +The text above provides a broad overview of some of the PEP 8 guidelines and conventions for writing **Python** code. It is not fully inclusive all of all the standards which are included in the full, online PEP 8 documentation. -::: +## Tools For Applying PEP 8 Formatting To Your Code -:::{admonition} Terminology Review -:class: tip +There are many different tools that can help you write code that is PEP 8 compliant. A tool that checks the format of your code is called a linter. -First, let's review some terminology associated with naming conventions. +Some linters will reformat your code for you to match the standards. These include tools like Black. Or the autopep8 tool for Jupyter Notebook. -* **Lowercase letter:** `b` -* **Uppercase letter:** `B` -* **lowercase:** `this is all lowercase words` -* **snake case:** when words are separated by underscores: `lower_case_with_underscores` -* **Uppercase:** All words are all uppercase letters: `UPPERCASE` -* **Snake case** upper case: `UPPER_CASE_WITH_UNDERSCORES` -* **CamelCase:** Every word is capitalized so they visually stand out: `CapitalizedWords`. This is sometimes also referred to as CapWords or StudlyCaps. - * Note: When using acronyms in CamelCase, capitalize all the letters of the acronym. Thus HTTPServerError is better than HttpServerError. -* **mixedCase:** (differs from CapitalizedWords by initial lowercase character!) -* **Capitalized_Words_With_Underscores:** This approach is not recommended. Use one convention and stick with it. +Other linters will simply check your code and tell you if things need to be fixed. A few **Python** packages that perform linting are listed below. -::: +* pep8, a `Python` package that can help you check your code for adherence to the PEP 8 style guide. +* autopep8, another `Python` package that can be used to modify files to the PEP 8 style guide. -+++ {"editable": true, "slideshow": {"slide_type": ""}} +`Python` community members expect that your code will adhere to the PEP 8 standard, and if it does not, they generally will not be shy to tell you that your code is not "Pythonic"! -## Best practices for importing libraries - -### Import Python libraries at the top of your code - -It’s good practice to import all required libraries at the top of your **Python** script or in the first cell of a **Jupyter Notebook**. This helps anyone understand what packages are needed to run your code. It also follows PEP 8 conventions. - -### Organize your imports into groups - -PEP 8 recommends organizing imports in the following order: - -1. **Standard Library Imports**: These built-in modules come with Python, such as `os` and `glob`. You can find the full list [here](https://docs.python.org/3/library/index.html). -2. **Third-Party Imports**: Libraries that you install via `pip`, like `numpy` and `pandas`. -3. **Local Imports**: Code or modules specific to your project. - -Here’s an example following PEP 8 conventions: - -```python -import os -import glob ++++ {"editable": true, "slideshow": {"slide_type": ""}} -import numpy as np -import pandas as pd -import matplotlib.pyplot as plt +## Additional Resources -from my_module import my_function -``` +* The PEP 8 Style Guide -### Why organize imports? +* How To Write Beautiful Python Code with PEP 8 -Organizing your imports this way ensures your code is readable and follows widely accepted practices. Importing libraries at the top also makes it easier to debug and see which dependencies are required to run the code. +* The Hitchhiker's Guide to Python by Tanya Schlusser and Kenneth Reitz From bc8e3779f0881fad0058be5b82d95392dc785750 Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Wed, 9 Oct 2024 14:25:14 -0600 Subject: [PATCH 8/9] feat: cleanup activity 3 and test checks lesson --- .../activity-3/clean-code-activity-3.md | 46 +- .../python-function-checks.md | 216 ++++- .../checks-conditionals/tests-checks.md | 739 ------------------ clean-modular-code/intro-clean-code.md | 2 +- 4 files changed, 206 insertions(+), 797 deletions(-) delete mode 100644 clean-modular-code/checks-conditionals/tests-checks.md diff --git a/clean-modular-code/activity-3/clean-code-activity-3.md b/clean-modular-code/activity-3/clean-code-activity-3.md index ea827ed..48c23a1 100644 --- a/clean-modular-code/activity-3/clean-code-activity-3.md +++ b/clean-modular-code/activity-3/clean-code-activity-3.md @@ -48,7 +48,7 @@ IN THIS PR: https://github.com/pyOpenSci/lessons/pull/14/files#diff-7f4ff1b75e85d38f3955cca051e68e8746773c279b34c9a0a400b9c2dc1240ff ::: -When you can, try to use the Pythonic approach of asking for forgiveness later (ie use try/except blocks) rather than conditional statements. +When you can, try to use the Pythonic approach of asking for forgiveness later (ie use try/except blocks) rather than conditional statements. ```{code-cell} ipython3 --- @@ -89,34 +89,31 @@ def clean_title(title): +++ {"editable": true, "slideshow": {"slide_type": ""}, "tags": ["hide-output", "hide-cell"]} -TODO - move this to activity 2 it doesn't belong in activity 3! - -### Applying functions to dataframe values - .apply +:::{tip} +### Applying functions to DataFrame values--`.apply` -The `.apply()` function in pandas allows you to apply any function to rows or columns in a `pandas.DataFrame`. For example, You can use it to perform operations on specific column or row values. When you use .apply(), you can specify whether you want to apply the function across columns (axis=0, the default) or across rows (axis=1). For example, if you want to apply a function to each row of a DataFrame, you would use df.apply(your_function, axis=1). This function is especially useful for applying logic that can’t be easily achieved with built-in pandas functions, allowing for more flexibility in data processing. +The `.apply()` function in pandas allows you to apply any function to rows or columns in a `pandas.DataFrame`. For example, You can use it to perform operations on specific column or row values. When you use `.apply()`, you can specify whether you want to apply the function across columns `(axis=0)` (the default) or across rows `(axis=1)`. For example, if you want to apply a function to each row of a DataFrame, you would use `df.apply(your_function, axis=1)`. This function is especially useful for applying logic that can’t be easily achieved with built-in pandas functions, allowing for more flexibility in data processing. -You can use `.apply` in pandas as an efficient replacement for `for loops` to process row and column values in a df. +You can use `.apply` in pandas to efficiently replace `for loops` to process row and column values in a `pandas.DataFrame`. -```{code-cell} ipython3 -a=1 -``` +::: +++ {"editable": true, "slideshow": {"slide_type": ""}} -The code below is an example of what your code might look like after completing activity 2. +### What's changed in your workflow? -You can choose to work with this code, or you can use the code that you completed in activity 2. - -### What's changed - -For this activity, you now have a new data file to open in your list of .json files. This file has some unexpected "features" that you will need to ensure your code handles gracefully. +:::{warning} +You have a new data file to open in your list of `.json` files in this activity. This file has some unexpected "features" that your code needs to handle gracefully so it can process all of the data. +::: -Your goal is similar to ensure that the code below runs. +Your goal is to make the code below run on the data provided in the activity-3 `data/` directory. :::{tip} The code below will fail. You will likely want to use a debugger to determine why it's failing and get the code running. ::: +The code below is an example of what your code might look like after completing activity 2. You can choose to work with this code, or you can use the code that you completed in activity 2. + +++ {"editable": true, "slideshow": {"slide_type": ""}, "tags": ["raises-exception"]} ```python @@ -221,6 +218,23 @@ all_papers_df = pd.concat(all_papers_list, axis=0, ignore_index=True) print("Final shape of combined DataFrame:", all_papers_df.shape) ``` ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +:::{admonition} On your own 1 +:class: attention + +Ideas for on your own welcome! +::: + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +:::{admonition} On your own 2 +:class: attention +Ideas welcome? +::: + +I want to have them move their code into a module if possible during this workshop but we could also kick that off in the day 2 workshop. + ```{code-cell} ipython3 --- editable: true diff --git a/clean-modular-code/checks-conditionals/python-function-checks.md b/clean-modular-code/checks-conditionals/python-function-checks.md index ebd8668..90de516 100644 --- a/clean-modular-code/checks-conditionals/python-function-checks.md +++ b/clean-modular-code/checks-conditionals/python-function-checks.md @@ -15,86 +15,220 @@ kernelspec: # Write Flexible Functions to Handle Messy Data -When dealing with messy or unpredictable data, using functions is an excellent first step in creating a robust and maintainable data processing workflow. Functions provide modular units that can be tested independently, allowing you to handle various edge cases and unexpected scenarios effectively. - -## Function benefits - -Using functions in your data processing pipeline offers several advantages: - -1. **Modularity**: Functions encapsulate specific tasks, making your code more organized and easier to understand. -2. **Testability**: You can test functions individually, outside of the main workflow, to ensure they handle different scenarios correctly. -3. **Flexibility**: As you build out your workflow, you can easily add elements to functions to handle new processing requirements or edge cases. -4. **Reusability**: Well-designed functions can be reused across different parts of your project or even in other projects. +When dealing with messy or unpredictable data, [using functions](python-functions) is an excellent first step in creating a robust and maintainable data processing workflow. Functions provide modular units that can be tested independently, allowing you to handle various edge cases and unexpected scenarios effectively. ## Handling edge cases -When working with messy data, you'll often encounter edge cases - unusual or unexpected data that can break your processing pipeline. Functions allow you to implement robust error handling and data validation. Here are some techniques you can use: +When working with messy data, you'll often encounter edge cases - unusual or unexpected data that can break your processing pipeline. You can add checks to your functions to handle potentail errors you may encounter in your data. +++ {"editable": true, "slideshow": {"slide_type": ""}} ## Try/Except blocks -Try/except blocks allow you to catch and handle exceptions that might occur during data processing. This is particularly useful when dealing with operations that might fail, such as type conversions or accessing nested data structures. + +Try/except blocks help you catch and handle errors that might happen while your code is running. This is useful for tasks that might fail, like converting data types or working with data that’s missing or incorrect. + +A try/except block looks like this: + +```python +try: + # code that might cause an error +except SomeError: + # what to do if there's an error +``` ```{code-cell} ipython3 -def safe_convert_to_int(value): +--- +editable: true +slideshow: + slide_type: '' +--- +def convert_to_int(value): try: return int(value) except ValueError: + print("Oops i can't process this so I will fail gracefully.") return None # or some default value +``` -# Example usage -result = safe_convert_to_int("123") # Returns 123 -result = safe_convert_to_int("abc") # Returns None +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +convert_to_int("123") +``` + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +convert_to_int("abc") ``` +++ {"editable": true, "slideshow": {"slide_type": ""}} -This function attempts to convert a value to an integer, returning None if the conversion fails. +This function attempts to convert a value to an integer, returning None and a message if the conversion fails. ## Make checks Pythonic Python has a unique philosophy regarding handling potential errors or exceptional cases. This philosophy is often summarized by the acronym EAFP: "Easier to Ask for Forgiveness than Permission." -### EAFP vs LBYL +### EAFP vs. LBYL There are two main approaches to handling potential errors: -LBYL (Look Before You Leap): Check for conditions before making calls or accessing data. -EAFP (Easier to Ask for Forgiveness than Permission): Assume the operation will succeed and handle any exceptions if they occur. +**LBYL (Look Before You Leap)**: Check for conditions before making calls or accessing data. +**EAFP (Easier to Ask for Forgiveness than Permission)**: Assume the operation will succeed and handle any exceptions if they occur. -Python generally favors the EAFP approach, which often leads to cleaner and more readable code. Here's an example to illustrate the difference: +Pythonic code generally favors the EAFP approach. ```{code-cell} ipython3 -# LBYL approach -def get_value_lbyl(dictionary, key, default=None): - if key in dictionary: - return dictionary[key] +--- +editable: true +slideshow: + slide_type: '' +--- +# LBYL approach - manually check that the user provides a int +def convert_to_int(value): + if isinstance(value, int): + return int(value) else: - return default + print("Oops i can't process this so I will fail gracefully.") + return None + +convert_to_int(1) +convert_to_int("a") +``` -# EAFP approach -def get_value_eafp(dictionary, key, default=None): +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- +# EAFP approach - Consider what the user might provide and catch the error. +def convert_to_int(value): try: - return dictionary[key] - except KeyError: - return default + return int(value) + except ValueError: + print("Oops i can't process this so I will fail gracefully.") + return None # or some default value + +convert_to_int(1) +convert_to_int("a") +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +The EAFP (Easier to Ask for Forgiveness than Permission) approach is more Pythonic because: + +* It’s often faster, avoiding redundant checks when operations succeed. +* It’s more readable, separating the intended operation and error handling. + +## Any Check is a Good Check + +As long as you consider edge cases, you're writing great code! You don’t need to worry about being “Pythonic” immediately, but understanding both approaches is useful regardless of which approach you chose. + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +## Common Python exceptions -# Example usage +Python has dozens of specific errors that can be raised when code fails to run. Below are a few common ones that you may encounter in the activity 3. + +### TypeError + +Occurs when an operation is applied to an object of an inappropriate type. + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +tags: [raises-exception] +--- +# Example: Trying to add a number and a string +1 + 'string' # This will raise a TypeError +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +### ValueError + +- **Raised when** a function receives an argument of the right type but an invalid value. +- **Example:** `int('abc')` (trying to convert an invalid string to an integer). + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +tags: [raises-exception] +--- +int("abc") +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +### KeyError + +- **Raised when** a dictionary key is not found. +- **Example:** `my_dict['nonexistent_key']` (trying to access a key that doesn’t exist in the dictionary). + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +tags: [raises-exception] +--- +# Example: Accessing a nonexistent key in a dictionary my_dict = {"a": 1, "b": 2} -print(get_value_lbyl(my_dict, "c", 0)) # Returns 0 -print(get_value_eafp(my_dict, "c", 0)) # Returns 0 +my_dict['nonexistent_key'] +``` + ++++ {"editable": true, "slideshow": {"slide_type": ""}} + +### IndexError: + +- **Raised when** an invalid index is used to access a list or tuple. +- **Example:** `my_list[10]` (trying to access the 11th element of a list with fewer elements). + +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +tags: [raises-exception] +--- +my_list = [1, 2, 3] +my_list[10] ``` +++ {"editable": true, "slideshow": {"slide_type": ""}} -The EAFP approach is considered more Pythonic because: +### AttributeError: -It's often faster, as it avoids redundant checks in the common case where the operation succeeds. -It's more readable and expressive, clearly showing the intended operation and the exception handling separately. -It helps avoid race conditions in certain scenarios, particularly in multi-threaded environments. +Raised when an object does not have a specific attribute or method. -## Any check is a good check +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +tags: [raises-exception] +--- +my_string = "Hello" +my_string.nonexistent_method() +``` -Ultimately, as long as you are considering the various edge cases your code may encounter when creating functions, you are writing great code! You don't have to worry about being Pythonic. +```{code-cell} ipython3 +--- +editable: true +slideshow: + slide_type: '' +--- -However, it's good to understand the value of both approaches and to get in the habit of writing Pythonic code sooner rather than later as a good practice! +``` diff --git a/clean-modular-code/checks-conditionals/tests-checks.md b/clean-modular-code/checks-conditionals/tests-checks.md deleted file mode 100644 index 2cd4b60..0000000 --- a/clean-modular-code/checks-conditionals/tests-checks.md +++ /dev/null @@ -1,739 +0,0 @@ ---- -jupytext: - text_representation: - extension: .md - format_name: myst - format_version: 0.13 - jupytext_version: 1.16.4 -kernelspec: - display_name: Python 3 (ipykernel) - language: python - name: python3 ---- - -+++ {"id": "d8b23008", "editable": true, "slideshow": {"slide_type": ""}} - -# Tests, Checks & Failing Gracefully - -:::{todo} -2. Add a section using dictionaries as examples (maybe where I talk about list comprehensions), as this will avoid key errors. -3. add a section on different types of Python errors to think about -::: - -Adding tests and checks to your Python code, in the form of: - -* try-except blocks, and -* conditional statements, - -helps you write code that can: - -* Better handle errors and edge cases gracefully, and -* Provide useful output about why things are going wrong for a user of your code. - -Tests and checks allow your code to either continue processing when it encounters an issue or fail in a controlled and graceful way. They can also provide useful error messages that help users debug the problem. - -Adding checks to your code is crucial for maintaining robust, reliable code. - -## What you will learn here - -In this interactive lesson, you will learn how to create a workflow that: - -1. Incorporates the clean code best practices you learned in the previous lessons, including following Pep 8 style standards, writing expressive code, and making your code DRY and modular. -2. Adds tests and checks using Python `try/except` blocks to capture common errors in the code. - -By the end of this lesson, you will have a script that runs a workflow combined with a small module that contains functions that you can use to create a Python package. - - -### Types of checks - -You can add checks to your workflow that either: - -1. continue processing the code even when it encounters a problem or -2. fail gracefully in a way that you can see what went wrong - -Below you will develop a workflow that parses software and journal paper DOI (Digital Object Identifiers) in URL format and returns reference information for each published entity. - -Most of the DOIs on this page represent pyOpenSci packages that have also been reviewed by the [Journal of Open Source Software](https://joss.theoj.org/). - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -## Some common errors that you will see - -Python has dozens of specific errors that can be raised when code fails to run. Understanding what the error codes mean is helpful for both troubleshooting code and also adding checks to your code to address specific errors. - -Below are a few of the common errors that Python can raise. - -### TypeError - -Occurs when an operation is applied to an object of an inappropriate type. - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' -tags: [raises-exception] ---- -# Example: Trying to add a number and a string -1 + 'string' # This will raise a TypeError -``` - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -### ValueError - -- **Raised when** a function receives an argument of the right type but an invalid value. -- **Example:** `int('abc')` (trying to convert an invalid string to an integer). - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' -tags: [raises-exception] ---- -int('abc') -``` - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -### KeyError - -- **Raised when** a dictionary key is not found. -- **Example:** `my_dict['nonexistent_key']` (trying to access a key that doesn’t exist in the dictionary). - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' -tags: [raises-exception] ---- -# Example: Accessing a nonexistent key in a dictionary -my_dict = {"a": 1, "b": 2} -my_dict['nonexistent_key'] -``` - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -### IndexError: - -- **Raised when** an invalid index is used to access a list or tuple. -- **Example:** `my_list[10]` (trying to access the 11th element of a list with fewer elements). - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' -tags: [raises-exception] ---- -my_list = [1, 2, 3] -my_list[10] -``` - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -### AttributeError: - -Raised when an object does not have a specific attribute or method. - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' -tags: [raises-exception] ---- -my_string = "Hello" -my_string.nonexistent_method() -``` - -```{code-cell} ipython3 ---- -editable: true -id: 1f1c256a -slideshow: - slide_type: '' ---- -import pandas as pd -from habanero import Crossref -``` - -+++ {"id": "69cfa634"} - -The **.csv file** that you read in contains a list of doi urls. - -```{code-cell} ipython3 ---- -editable: true -id: '80167539' -slideshow: - slide_type: '' ---- -# Open the data -file_path = "doi_urls.csv" -doi_df = pd.read_csv(file_path) -doi_df.head(2) -``` - -+++ {"id": "58d03c6f", "editable": true, "slideshow": {"slide_type": ""}} - -In this lesson, you will build a workflow around citable published software. You will use a pre-created dataset that contains cross-ref citations for open source software reviewed by the Journal of Open Source Software (JOSS). - -:::{important} -All the data used in this lesson can be accessed using Python using the Habanero package. However, you will be using a pre-processed dataset containing some "features" that you will have to work around to successfully process your data. -::: - -## About DOI's - -:::{admonition} What is a DOI? -A DOI, or [Digital Object Identifier](https://www.doi.org/), is a unique identifier that references a paper. A DOI acts as a URL, resolving to a specific location—in this case, the location is associated with citation information for a scientific paper or Python package that has been accepted into a journal such as the [Journal of Open Source Software (JOSS)](https://joss.theoj.org/). - -In this lesson, you use cross-ref DOIs, which resolve to the cross-ref database. Cross-ref also lets you see what other publications have cited for that specific DOI. -::: - -```{code-cell} ipython3 ---- -editable: true -id: d3738f2a -slideshow: - slide_type: '' ---- -doi_df["doi_url"][0] -``` - -+++ {"id": "37ef78f8"} - -## Create a workflow that processes a list of DOi's - -In this lesson, you will process a list of DOIs contained in a .csv file for pyOpenSci-accepted packages that both pyOpenSci and JOSS have also accepted through our software peer review partnership. - - -### Workflow goals -Your goal is to process all of the URLs in the citation file and get both the author(s) and titles of the reference. You then want to return the following values: - -1. the authors of the paper -2. the paper title -3. the number of references the paper has - -Like any URL, not all DOIs will resolve properly. - -You will use Pandas to read the .csv file with the DOI. You will then use the [habanero](https://habanero.readthedocs.io/en/latest/) package to parse that cross-ref DOI and return metadata about the published item. - -Below you open the data for a single DOI. Notice that the citation data for that DOI is to Python and stored as a `Dictionary.` - -There is a lot of information to process. Luckily, for your work today, you only need to process a few items in this dataset. - -```{code-cell} ipython3 ---- -editable: true -id: 38b2d444 -slideshow: - slide_type: '' ---- -cr = Crossref() -# Grab a single doi -url = doi_df["doi_url"][0] -# View reference information for that DOI -ref_dict = cr.works(ids=url) -ref_dict.keys() -``` - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' ---- -ref_dict["message"]["title"] -``` - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' ---- -ref_dict["message"] -``` - -```{code-cell} ipython3 -author_count = len(ref_dict["message"]["author"]) -author_count -``` - -+++ {"id": "495d50c1"} - -You can access the specific reference information including journal title, year, author using the `["reference"]` key. - -```{code-cell} ipython3 -:id: 0b8f76ce-0368-42cf-8299-cb7bd5513664 - -# View first reference for this citation -ref_dict["message"]["reference"][0] -``` - -```{code-cell} ipython3 ---- -editable: true -slideshow: - slide_type: '' ---- -citation_count = len(ref_dict["message"]["reference"]) -print(f"The package has {citation_count} citations and {author_count} authors.") -``` - -+++ {"id": "fc58802d"} - -## Process all DOI URLs in the .csv file - -Next, creat a workflow that processes each DOI in your dataframe of DOIs. - -```{code-cell} ipython3 ---- -editable: true -id: 307e4899 -slideshow: - slide_type: '' -tags: [raises-exception] ---- -# Without the function, your code would look like this: -cr = Crossref() -all_refs = [] -for adoi in doi_df["doi_url"]: - #print(adoi) - ref_info = cr.works(ids=adoi) - all_refs.append(all_refs.append(ref_info["message"].get("reference", []))) - -all_refs -``` - -+++ {"id": "bede9522"} - -*Oops looks like you have a point of failure.* - -## Some issues: - -1. Once you hit a point of failure, processing stops. -2. You are not sure where it fails or why - -+++ {"id": "c0b639c0"} - -## When Workflows Fail -Sometimes your code may fail in certain scenarios. Having checks in place in your code to catch these points of failure can be useful for many reasons: - -1. If your workflow is big, it's often time consuming to start over -2. If your workflow is big, it can be challening to identify where the point of failure is and what is causing it. - -+++ {"id": "fc26a6b8"} - -If you are using LLM's to help you code, you may find that the LLM can't correctly guess the types of errors that you may encounter with downloaded data such as the DOI reference data that you are working with here. However, it can help you create checks for issues that you find in the data if you wish to use it that way. - -Here, you receive a `KeyError` in your code that tells you that the -The "reference" key for the DOI data can not be found for at least one of your DOIs. - -How can you troubleshoot this? - -:::{dropdown} Tips to troubleshoot your KeyError - -There are a few different ways that you can troubleshoot this problem. - -1. A simple way is to add a print statement to your loop to identify what URL it's failing on. You can then look at the data and add a workaround. -2. You can add a breakpoint in your code if you work in an IDE with a debugger. This breakpoint will allow you to identify where the error is occurring. -3. You can add a try/except statement to print out the error but allow your code to keep running. You will learn more about try/except statements below. -4. Add a conditional statement to your look that catches a url with a missing reference key and sets the reference count to `None`. - -* debugger in JupyterLab -* debugger using vscode - -For this lesson, if you are not already familiar with a debugger, you can add a print statement or an iterator to determine what URL it's failing on. -::: - -## LLM's and error messages - -In some cases, particularly with Python, LLMs can be particularly useful for troubleshooting long error messages. - -```{code-cell} ipython3 ---- -editable: true -id: 01c7443e -slideshow: - slide_type: '' -tags: [raises-exception] ---- -# This returns a key error -url = doi_df["doi_url"][5] -ref_dict = cr.works(ids=url) -# View first reference in dics -ref_dict["message"]["reference"] -``` - -+++ {"id": "9d67f470"} - -## Check To See if the Key Exists - -```{code-cell} ipython3 -:id: e665aec2 - -# Does the reference exist in the data? -"reference" in ref_dict["message"].keys() -``` - -+++ {"id": "0caf5a2b"} - -## Write a Function that Checks that the Reference Exists in the Data - -```{code-cell} ipython3 -:id: 3fa84306 - -# This will return True if the reference exists, false if not -def check_reference_data(doi): - """Checks to see if a specific doi has a list of references associated with it - - Parameters - ---------- - doi : string - DOI string for a reference - - Returns - ------- - Boolean : True if exists, False if not - """ - - response = cr.works(ids=doi) - return "reference" in response["message"].keys() -``` - -```{code-cell} ipython3 ---- -editable: true -id: 8c4fea64 -slideshow: - slide_type: '' ---- -# Your code is easier to read with a function -cr = Crossref() - -for adoi in doi_df["doi_url"]: - print(adoi) - print(check_reference_data(adoi)) -``` - -+++ {"id": "b2d59037"} - -Your workflow is failing. A -404 error which means that the URL for the doi is bad. - -`404 Client Error: Not Found for url: https://api.crossref.org/works/https://doi.org/10.5066/P9MR4XN4` - -+++ {"id": "b88e90bb"} - -To handle this error, you can consider implementing a try/except block: - -* Try will attempt to run something and if it fails, it moves on to the except statement. -* Let's add a try/except statement that returns None is the DOI url can't be accessed - -[A Good Carpentry Lesson on try/except](https://mq-software-carpentry.github.io/python-testing/03-exceptions/) - -+++ {"id": "f85981c7"} - -``` -# This is formatted as code -``` - -A try/except allows you to try a function or some code -If it doesn't run properly, you can then tell it what to return instead - -```{code-cell} ipython3 -:id: 658886e5 - -try: - response = cr.works(ids="bad url here") - print("Great - it runs with a good doi url.") -except: - # If the function fails to get a return for the DOI, return None - print("Oops, it didn't work out as planned, did it?") -``` - -+++ {"id": "d7c26087"} - -Here your code runs as planned - -```{code-cell} ipython3 -:id: 0a9bce89 - -try: - response = cr.works(ids=doi_df["doi_url"][2]) - print("Great - it runs with a good doi url.") -except: - # If the function fails to get a return for the DOI, return None - print("Oops, it didn't work out as planned, did it?") -``` - -+++ {"id": "970f0748"} - -Add your try/except block to your function - -```{code-cell} ipython3 -:id: 711c9564 - -# Add try/except to your function -def check_reference_data_err(doi): - """ - Checks to see if a specific doi has a list of - references associated with it - """ - - try: - response = cr.works(ids=doi) - except: - # If the function fails to get a return for the DOI, return None - return None - # Otherwise return true or false - return "reference" in response["message"].keys() -``` - -+++ {"id": "92315aa6"} - -This check in your code allows the code to -continue to run even when it encounters an error! - -```{code-cell} ipython3 -:id: 09e1bbfc - -for adoi in doi_df["doi_url"]: - print(check_reference_data_err(adoi)) -``` - -+++ {"id": "9e2f519c"} - -*italicized text*## Problem: Your Workflow Fails Quietly - -What if you wanted to catch and print out the error so that you can -better troubleshoot? For instance, what doi is it failing on? - - -Notice that below you "catch" the error thrown and print it. What this means -is that you can keep running your code, and the error will be printed bu -it will NOT halt processing. - -+++ {"id": "b8ae5d1f"} - -## Two options - -1. Catch the exception as a generic exception and print out the return. -2. Catch the specific exception (this is more advanced - don't worry about it for now) - -```{code-cell} ipython3 -:id: fb80796b - -# Add an exception that captures the error -def check_reference_data_try_err(doi): - """Checks to see if a specific doi has a list of references associated with it""" - try: - response = cr.works(ids=doi) - except Exception as err: - # Print the error message - print(err) - # If the function fails to get a return for the Doi, return None - return None - return "reference" in response["message"] -``` - -```{code-cell} ipython3 -:id: 84c4d129 - -for adoi in doi_df["doi_url"]: - print(check_reference_data_try_err(adoi)) -``` - -+++ {"id": "db044d20"} - -Now, your function returns a 404 error. -But what if the URL was actually NOT a url at all? -Is your code robust enough to tell you that? - -```{code-cell} ipython3 -:id: dc48062d - -# This returns a 404 but there is no URL in the string "Cookies" -check_reference_data_try_err("Cookies") -``` - -```{code-cell} ipython3 -:id: a19f5601 - -# Mess up one of the url's in your pdf -doi_df["doi_url"][11] = "cookies!" -doi_df -``` - -+++ {"id": "4d6b4a22"} - -## Test that the URL Begins with "http" - -Above you are assuming that the user has provided your function with a URL -however, you could also begin your function with a test to ensure that -the doi provided is in fact a URL. - -```{code-cell} ipython3 -:id: 1ff93fbe - -doi="cake" -if doi.startswith("http"): - print("Great - this is a proper url") -else: - print("Sorry, human. I don't see a proper url here.") -``` - -+++ {"id": "6e5a9408"} - -Here you provide a URL: - -```{code-cell} ipython3 -:id: 431d0b6b - -doi="https://www.pyopensci.org" -if doi.startswith("http"): - print("Great - this is a proper url") -else: - print("Sorry, human. I don't see a proper url here.") -``` - -+++ {"id": "4d7c5a1c"} - -Add this check to your function. Below the function will now -return a different value if the URL is bad. - -```{code-cell} ipython3 -:id: a9408f19 - -# Add an exception that captures the error -def check_reference_data_try_err(doi): - """Checks to see if a specific doi has a list of references associated with it""" - - if doi.startswith("http"): - try: - response = cr.works(ids=doi) - except Exception as err: - print(err) - # If the function fails to get a return for the Doi, return None - return None - else: - return "Missing Valid URL - " + doi - return "reference" in response["message"] -``` - -```{code-cell} ipython3 -:id: 3444331e - -# Let's try out the final function -for adoi in doi_df["doi_url"]: - print(check_reference_data_try_err(adoi)) -``` - -+++ {"id": "bfc7f989"} - -## On Your Own Challenge -Run the code cell below. -Answer the following questions: - -1. What happens when you run the cell below? -2. What could you do to address the issue below? - -If you have time, try out some solutions in this notebook. - -```{code-cell} ipython3 -:id: 473da2a3 - -check_reference_data_try_err(123) -``` - -```{code-cell} ipython3 -:id: bbb20ca1 - -# Your answer here -``` - -```{code-cell} ipython3 -# Initialize Crossref API client -cr = Crossref() - -# Define the ISSN of JOSS -joss_issn = "2475-9066" - -# Fetch DOIs of articles published in JOSS -results = cr.works(filter={"issn": joss_issn}, limit=100) -#results -``` - -+++ {"id": "39f64c05-7d33-4123-8781-034c94f3dffc"} - -https://github.com/lwasser/usgs-citations - -+++ - -The problem here with LLM's is that they will often provide answers that are only partially correct. The code below was provided on 12 Sept 2024 by ChatGPT 4o. - -There are parts of it that are good - for instance, it - -1. DRY: -2. create a function to gather data for a single doi -3. Uses a loop to iterate over the list of URLs -4. Tests & Checks: provides a nice try/except statement within the get_ - -It also -* doesn't run -* suggests that you visbalize the data using a internal chatgpt tool. - -+++ {"editable": true, "slideshow": {"slide_type": ""}} - -```python -# this is what chatgpt provides - 12 Sept 2024 - -import pandas as pd -from habanero import Crossref - -# Initialize the Crossref client -cr = Crossref() - -# Function to fetch paper details using habanero -def get_paper_details(doi): - try: - # Query CrossRef for the DOI - result = cr.works(ids=doi) - - # Extract the required information - authors = [f"{author['given']} {author['family']}" for author in result['message']['author']] - title = result['message']['title'][0] - references = result['message'].get('reference-count', 'N/A') # Some papers may not have this info - - return authors, title, references - - except Exception as e: - print(f"Error fetching data for DOI {doi}: {e}") - return None, None, None - -# Load the CSV file -df = pd.read_csv('doi_urls.csv') - -# Initialize a list to store the results -results = [] - -# Process each DOI -for doi in df['DOI']: - authors, title, references = get_paper_details(doi) - results.append({ - 'DOI': doi, - 'Title': title, - 'Authors': authors, - 'Reference Count': references - }) - -# Create a new DataFrame from the results -results_df = pd.DataFrame(results) - -# Display the results - this is using a internal openai tool :) -import ace_tools as tools; tools.display_dataframe_to_user(name="Paper Details", dataframe=results_df) -``` diff --git a/clean-modular-code/intro-clean-code.md b/clean-modular-code/intro-clean-code.md index b2a9d7b..6c7cbff 100644 --- a/clean-modular-code/intro-clean-code.md +++ b/clean-modular-code/intro-clean-code.md @@ -42,7 +42,7 @@ Expressive Code Multi-variable functions Conditional statements -Tests & Checks +Tests & Checks ::: :::{toctree} From e1b297ae24efa6bf6654bb61c4cc05198b501c63 Mon Sep 17 00:00:00 2001 From: Leah Wasser Date: Fri, 11 Oct 2024 14:13:15 -0600 Subject: [PATCH 9/9] Apply suggestions from code review Co-authored-by: Jeremy Paige --- clean-modular-code/activity-3/clean-code-activity-3.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clean-modular-code/activity-3/clean-code-activity-3.md b/clean-modular-code/activity-3/clean-code-activity-3.md index 48c23a1..ff3f213 100644 --- a/clean-modular-code/activity-3/clean-code-activity-3.md +++ b/clean-modular-code/activity-3/clean-code-activity-3.md @@ -22,7 +22,7 @@ In this activity, you will build checks into your workflow to handle data proces ### Real world data processing & workflows and edge cases -Real-world data rarely can be imported without "work arounds". You will often find unusual data entries and values you don't expect. Sometimes, these values are documented - for example, a 9999 may represent a missing value in a dataset. Other times, there are typos and other errors in the data that you need to handle. Sometimes, call these unusual values or instances in a dataset or workflow "edge cases". +Real-world data rarely can be imported without "work arounds". You will often find unusual data entries and values you don't expect. Sometimes, these values are documented - for example, a 9999 may represent a missing value in a dataset. Other times, there are typos and other errors in the data that you need to handle. These unusual values or instances in a dataset or workflow are sometimes called "edge cases". Writing robust code that handles unexpected values will make your code run smoothly and fail gracefully. This type of code, which combines functions (or classes) and checks within the functions that handle messy data, will make your code easier to maintain over time.