riser 1.1.0__tar.gz

riser-1.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 rzinke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

riser-1.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: riser
+Version: 1.1.0
+License: MIT License
+        
+        Copyright (c) 2025 rzinke
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Requires-Python: >=3.12
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.9.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: scipy>=1.13.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: tqdm>=4.67.1
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: types-toml; extra == "dev"
+Requires-Dist: scipy-stubs; extra == "dev"
+Requires-Dist: types-tqdm; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Dynamic: license-file

riser-1.1.0/README.md

@@ -0,0 +1,117 @@
+# ***R***ejection sampling for ***I***ncremental ***S***lip ***R***ate calculation v.**2** – RISeR2
+
+![alt text](https://github.com/rzinke/RISeR2/blob/main/assets/RISeR_logo-name.png "RISeR")
+
+## Purpose
+Earthquake fault slip rates describe the displacement accumulation rate across a fault, averaged over some time interval. Slip rates are determined from geologic, geomorphic, or sedimentary markers recording measureable fault slip, and which can be dated using absolute geochronologic methods. Where multiple dateable displacement markers share a common slip history and record different epochs in that history, one can determine *incremental* slip rates. These average over shorter intervals relative to the oldest displacement, and can show the constancy or variability of fault slip over time.
+
+**RISeR2** is designed to measure incremental fault slip rates based on the dated displacement history of a fault while fully accounting for uncertainties in the ages, displacements, and derived slip rates. It allows enforcement of Bayesian conditions, including the assumption that the fault did not slip backward at any point in its history. The RISeR2 library hosts a set of analytical functions and sampling tools for computing slip rates; formatting, conditioning, and displaying data; and analyzing the results.
+
+![alt text](https://github.com/rzinke/RISeR2/blob/main/assets/incremental_slip_rates.png "incremental slip rates example")
+
+*Example incremental slip rates. Three incremental rates are computed between pairs of among four dated displacement markers (Marker 01–Marker 04). The exact value of each incremental slip rate is uncertain, therefore possible slip rate values are expressed as probability densities. Blue fields show the most probability 68.2% of values.*
+
+## Setup
+RISeR2 can be used as a set of command line tools or as an API. The command line tools form an adaptable pipeline for handling and computing probability density functions, and the API modules form a generalized PDF laboratory.
+
+### Installation
+To install RISeR2, simply run the following command in a UNIX shell:
+
+```
+pip install git+https://github.com/rzinke/RISeR2.git
+```
+
+### Development Setup
+To use these scripts, clone the GitHub repository to a location of your choice and navigate to that folder.
+
+Note: It is recommended to use a Python package manager such conda or mamba. Create a new environment with the necessary packages installed and activate it:
+
+```
+conda env create -n riser -f requirements.yaml
+conda activate riser
+```
+
+Then install RISeR2 into that environment:
+
+```
+pip install -e .
+```
+
+OR
+
+```
+pip install -e ".[dev]"
+```
+
+if you are developing.
+
+
+## Top-level Functions and Examples
+RISeR2 provides three command line functions for determining slip rates:
+
+ - `riser-compute-slip-rate`
+ - `riser-compute-slip-rates`
+ - `riser-compute-slip-rates-mc`
+
+Each tool is designed for different scenarios, and to incorporate different assumptions. See [Slip rate determination](#slip-rate-determination).
+
+Example data sets and launch scripts can be found in the `RISeR2/examples` folder.
+
+
+## Under the Hood
+For a single dated measurement of fault displacement, a fault **slip rate** measured since the present day is defined as:
+
+$\bar{v} = \frac{u}{t}$
+
+where $\bar{v}$ is the slip rate averaged over time, $u$ is the displacement across the fault, and $t$ is the time interval over which the displacement accumulated. If multiple dated displacement markers are available along a fault (and all share a common slip history), a displacement-time history or slip history can be determined. For $n$ dated markers, $m = n - 1$ closed intervals in the fault slip history are defined. Slip rates averaged over closed intervals are ***incremental*** **slip rates**, defined as:
+
+$\bar{v}_i = \frac{\Delta u_i}{\Delta t_i}$
+
+where $i$ is one of the $m$ closed intervals, and $\Delta$ is the change in displacement or time within each interval. RISeR2 is specifically designed to compute incremental slip rates.
+
+Often, both the displacement measurement and age of the feature have non-negligible uncertainties. These uncertainties can be expressed as *probability density functions (PDFs)*, which express the *relative likelihood* of any *value* (e.g., time or age, displacement, slip rate, *etc.*) as a function of values. A PDF can take on any shape that adheres to the following criteria:
+ - Probability density is never negative. It can be zero or positive over the range of all possible values.
+ - The area under the curve is 1.0. I.e., the event is guaranteed to have occurred at some point in the defined values.
+
+Strictly defined, a PDF is absolutely continuous (defined over infinitely many values). RISeR2 uses *discrete PDFs*, represented by a discrete and finite vector of possible values, each with a corresponding probability density. The probability density of any value within the vector of PDF values can be determined by linear interpolation between defined probability densities, and values outside the defined vector are assigned zero probability density. Use of discrete PDFs is essential because RISeR2 is designed to work with non-parametric functions (such as calibrated radiocarbon dates) that cannot be described by closed-form equations.
+
+**`PDFs`** are the fundamental object in the RISeR2 library. All ages, displacements, and slip rates are expressed as PDFs with the above properties. The PDF can be given a descriptive *name*, and a description of the *variable-type*, e.g., "age", "displacement", "slip rate". The PDF can also be assigned a *unit*—RISeR2 recognizes units consisting of multiples of years (**y**) and meters (**m**).
+
+![alt text](https://github.com/rzinke/RISeR2/blob/main/assets/S1cal_age.png "example multi-modal PDF")
+
+*Example of a multi-modal (multi-peaked) PDF. Blue field indicates the most probable 95.4% of values.*
+
+Data points defining displacement-time history of a fault are encoded as a **`DatedMarker`**, comprising a PDF representing *age*, and a PDF representing *displacement*. Like a PDF, a DatedMarker can carry a descriptive name. The unit (e.g., "m/y") is determined from the units of the constituent age and displacement PDFs.
+
+![alt text](https://github.com/rzinke/RISeR2/blob/main/assets/dated_markers.png "example dated markers")
+
+*Example of a series of dated displacement markers, defining the slip history of a hypothetical fault.*
+
+
+### Slip rate determination
+
+`riser-compute-slip-rate` is used to determine the slip rate of a fault since present day, based on a single DatedMarker. It uses the analytical formulation (a weighted convolution) of Bird (2007).
+
+`riser-compute-slip-rates` is used to compute incremental slip rates between multiple DateMarkers using convolution-based analytical formulas. It assumes that neither the change in age between markers $\Delta t$, nor the change in displacement $\Delta u$ are negative.
+
+`riser-compute-slip-rates-mc` invokes Monte Carlo-style sampling of the ages and displacements of multiple DateMarkers in a slip history. The age and displacement PDFs are sampled according to their non-parametric forms using the **Probability Inverse Transform (PIT)** method. Multiple conditions can be enforced on whether the random samples are valid and accepted, or invalid and rejected in the process of **rejection sampling** (discussed in this context in Zinke et al., 2019). Like Gold & Cowgill (2011), `riser-compute-slip-rates-mc` enforces the assumption that the fault did not slip backwards (inversely to its overall kinematics) at any point in its history. This can be especially important in cases where ages and/or displacements uncertainties overlap. A maximum-allowable slip rate may also be provided, to avoid possibilities in which the fault slipped unrealistically fast over multiple earthquake cycles.
+
+
+## References
+ - Bird, P. (2007), Uncertainties in long-term geologic offset rates of faults: General principles illustrated with data from California and other western states, *Geosphere, 3*, 577–595, https://doi:10.1130/GES00127.1.
+ - Gold, R. D., & Cowgill, E. (2011). Deriving fault-slip histories to test for secular variation in slip, with examples from the Kunlun and Awatere faults. *Earth and Planetary Science Letters, 301*, 52–64. https://doi.org/10.1016/j.epsl.2010.10.011
+ - Zinke, R., Dolan, J. F., Rhodes, E. J., Van Dissen, R., McGuire, C. P., Hatem, A. E., et al. (2019). Multimillennial incremental slip rate variability of the Clarnce fault at the Tophouse Road site, Marlborough Fault System, New Zealand. *Geophysical Research Letters, 46*, 717–725. https://doi.org/10.1029/2018GL080688
+ - Zinke, R., Dolan, J. F., Rhodes, E. J., Van Dissen, R. J., Hatem, A. E., McGuire, C. P., et al. (2021). Latest Pleistocene–Holocene incremental slip rates of the Wairau fault: Implications for long-distance and long-term coordination of faulting between North and South Island, New Zealand. *Geochemistry, Geophysics, Geosystems, 22*, e2021GC009656. https://doi.org/10.1029/2021GC009656
+
+
+## Citation
+ - Zinke, R., Dolan, J. F., Rhodes, E. J., Van Dissen, R. J., Hatem, A. E., McGuire, C. P., et al. (2021). Latest Pleistocene–Holocene incremental slip rates of the Wairau fault: Implications for long-distance and long-term coordination of faulting between North and South Island, New Zealand. *Geochemistry, Geophysics, Geosystems, 22*, e2021GC009656. https://doi.org/10.1029/2021GC009656
+ - Zenodo: https://zenodo.org/records/4733235. https://doi.org/10.5281/zenodo.4733235
+
+
+## ⚠️ Disclaimer
+This codebase is provided for research and experimental purposes only.
+It may contain bugs, incomplete features, or incorrect implementations.
+
+No warranty is provided, express or implied, regarding the correctness or reliability of the code.
+By using this code, you agree that the authors and contributors are not liable for any damages or issues that may arise.

riser-1.1.0/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "riser"
+version = "1.1.0"
+license = {file = "LICENSE"}
+requires-python = ">=3.12"
+dependencies = [
+    "matplotlib>=3.9.0",
+    "numpy>=2.0.0",
+    "scipy>=1.13.0",
+    "toml>=0.10.2",
+    "tqdm>=4.67.1",
+]
+
+[project.optional-dependencies]
+dev = [
+    "mypy",
+    "types-toml",
+    "scipy-stubs",
+    "types-tqdm",
+    "pytest",
+    "ruff",
+    "sphinx",
+]
+
+[project.scripts]
+riser-add-variables = "riser.cli.add_variables:main"
+riser-calyr-to-age = "riser.cli.calyr_to_age:main"
+riser-combine-variables = "riser.cli.combine_variables:main"
+riser-compute-gap-probabilities = "riser.cli.compute_gap_probabilities:main"
+riser-compute-ks-statistic = "riser.cli.compute_ks_statistic:main"
+riser-compute-overlap-index = "riser.cli.compute_overlap_index:main"
+riser-compute-slip-rate = "riser.cli.compute_slip_rate:main"
+riser-compute-slip-rates = "riser.cli.compute_slip_rates:main"
+riser-compute-slip-rates-mc = "riser.cli.compute_slip_rates_mc:main"
+riser-cross-correlate-variables = "riser.cli.cross_correlate_variables:main"
+riser-divide-variables = "riser.cli.divide_variables:main"
+riser-interpolate-pdf = "riser.cli.interpolate_pdf:main"
+riser-make-pdf = "riser.cli.make_pdf:main"
+riser-merge-variables = "riser.cli.merge_variables:main"
+riser-multiply-variables = "riser.cli.multiply_variables:main"
+riser-subtract-variables = "riser.cli.subtract_variables:main"
+riser-view-displacement-age-history = "riser.cli.view_displacement_age_history:main"
+riser-view-pdf = "riser.cli.view_pdf:main"
+riser-view-pdf-stack = "riser.cli.view_pdf_stack:main"
+
+[tool.ruff]
+line-length = 80
+
+[tool.ruff.lint]
+ignore = ["UP009", "RUF022"]
+
+[tool.ruff.lint.isort]
+combine-as-imports = true
+lines-after-imports = 2

riser-1.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

riser-1.1.0/src/riser/__init__.py

@@ -0,0 +1,63 @@
+# src/riser/__init__.py
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2025 Rob Zinke. Licensed under the MIT License.
+
+"""
+RISeR2: Rejection sampling for Incremental Slip Rate calculation.
+"""
+
+from importlib.metadata import version as _version
+
+
+__version__ = _version("riser")
+
+
+# Core modules (no internal dependency)
+from . import (  # noqa: I001
+    constants,
+    integration,
+    precision,
+    units,
+    variable_types,
+)
+
+
+# Subpackages (imported in dependency order)
+from . import (
+    probability_functions,
+    variable_functions,
+    variable_pairs,
+    sampling,
+    slip_rates,
+    plotting,
+)
+
+
+# Commonly used classes
+from .probability_functions import PDF
+from .variable_pairs import DatedMarker, VariablePair
+
+
+# Public API
+__all__ = [
+    # Core modules and subpackages
+    "constants",
+    "integration",
+    "precision",
+    "units",
+    "variable_types",
+    "probability_functions",
+    "variable_functions",
+    "sampling",
+    "variable_pairs",
+    "slip_rates",
+    "plotting",
+    # Commonly used classes
+    "PDF",
+    "VariablePair",
+    "DatedMarker",
+]
+
+
+# end of file

riser-1.1.0/src/riser/cli/__init__.py

@@ -0,0 +1,11 @@
+# src/riser/cli/__init__.py
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2025 Rob Zinke. Licensed under the MIT License.
+
+"""
+Command Line Interface tools live here.
+"""
+
+
+# end of file

riser-1.1.0/src/riser/cli/add_variables.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2025 Rob Zinke. Licensed under the MIT License.
+
+
+# Import modules
+import argparse
+
+import matplotlib.pyplot as plt
+
+from riser import (
+    plotting,
+    probability_functions as PDFs,
+    variable_functions as var_fcns,
+)
+
+
+#################### ARGUMENT PARSER ####################
+description = "Add two random variables expressed as PDFs."
+
+examples = """Examples:
+add_variables.py pdf1.txt pdf2.txt -o pdf12.txt
+"""
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        description=description,
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=examples,
+    )
+
+    return parser
+
+def cmd_parser(iargs=None):
+    parser = create_parser()
+
+    input_args = parser.add_argument_group("Inputs")
+    input_args.add_argument(dest="fname1",
+        type=str,
+        help="File name of first PDF.")
+    input_args.add_argument(dest="fname2",
+        type=str,
+        help="File name of second PDF.")
+
+    input_args.add_argument("--name", dest="name",
+        type=str,
+        help="Name of summed PDF. [None]")
+
+    output_args = parser.add_argument_group("Outputs")
+    output_args.add_argument("-o", "--outname", dest="outname",
+        type=str, required=True,
+        help="Output file.")
+    output_args.add_argument("-v", "--verbose", dest="verbose",
+        action="store_true",
+        help="Verbose mode.")
+    output_args.add_argument("-p", "--plot", dest="plot",
+        action="store_true",
+        help="Plot distribution.")
+
+    return parser.parse_args(args=iargs)
+
+
+#################### MAIN ####################
+def main() -> None:
+    # Parse arguments
+    inps = cmd_parser()
+
+    # Read PDFs from files
+    pdf1 = PDFs.readers.read_pdf(inps.fname1, verbose=inps.verbose)
+    pdf2 = PDFs.readers.read_pdf(inps.fname2, verbose=inps.verbose)
+
+    # Sample PDFs on same axis
+    pdf1, pdf2 = PDFs.interpolation.interpolate_pdfs(
+        [pdf1, pdf2], verbose=inps.verbose
+    )
+
+    # Compute summed PDF
+    sum_pdf = var_fcns.transform.arithmetic.add_variables(
+        pdf1, pdf2, name=inps.name, verbose=inps.verbose
+    )
+
+    # Save to file
+    PDFs.readers.save_pdf(inps.outname, sum_pdf, verbose=inps.verbose)
+
+    # Plot function if requested
+    if inps.plot:
+        # Initialize figure and axis
+        fig, (inpt_ax, sum_ax) = plt.subplots(nrows=2)
+
+        # Plot input PDFs
+        plotting.plot_pdf_filled(inpt_ax, pdf1)
+        plotting.plot_pdf_filled(inpt_ax, pdf2)
+
+        # Plot PDF
+        plotting.plot_pdf_labeled(sum_ax, sum_pdf)
+
+        # Format figure
+        inpt_ax.legend()
+        inpt_ax.set_title("Inputs")
+        sum_ax.set_title("Summed PDF")
+        fig.tight_layout()
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()
+
+
+# end of file

riser-1.1.0/src/riser/cli/calyr_to_age.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2025 Rob Zinke. Licensed under the MIT License.
+
+
+# Import modules
+import argparse
+
+import matplotlib.pyplot as plt
+
+from riser import (
+    plotting,
+    probability_functions as PDFs,
+    sampling,
+    units,
+)
+
+
+#################### ARGUMENT PARSER ####################
+description = (
+    "Convert an age PDF from calendar years to (kilo)years before present."
+)
+
+examples = """Examples:
+riser-calyr-to-age C_date.txt -o C_age.txt
+riser-calyr-to-age C_date.txt --name C14 --smoothing-type mean --smoothing-width 3 -v -p -o C_age.txt
+"""
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        description=description,
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=examples,
+    )
+
+    return parser
+
+def cmd_parser(iargs=None):
+    parser = create_parser()
+
+    input_args = parser.add_argument_group("Inputs")
+    input_args.add_argument(dest="date_fname",
+        type=str,
+        help="Calendar years file name.")
+
+    # Metadata
+    metadata_args = parser.add_argument_group("Metadata")
+    metadata_args.add_argument("--name", dest="name",
+        type=str,
+        help="Name.")
+    metadata_args.add_argument("--variable-type", dest="variable_type",
+        type=str, default="age",
+        help="Variable type. [age]")
+
+    # Referencing
+    referencing_args = parser.add_argument_group("Referencing")
+    referencing_args.add_argument("--reference-date", dest="reference_date",
+        type=float, default=1950,
+        help="Reference date, e.g., 1950 for radiocarbon, 2000 for OSL, etc. "
+             "[1950]")
+    referencing_args.add_argument("--limit-zero", dest="limit_zero",
+        action="store_true",
+        help="Limit youngest value to zero.")
+
+    # Units
+    unit_args = parser.add_argument_group("Units")
+    unit_args.add_argument("--input-unit", dest="input_unit",
+        type=str, default="y",
+        help="Unit of input data. [y]")
+    unit_args.add_argument("--output-unit", dest="output_unit",
+        type=str, default="ky",
+        help="Unit of output data. [ky]")
+
+    # Smoothing
+    smoothing_args = parser.add_argument_group("Smoothing")
+    smoothing_args.add_argument("--smoothing-type", dest="smoothing_type",
+        type=str, choices=sampling.filtering.FILTER_TYPES,
+        help="Smoothing filter type. [None]")
+    smoothing_args.add_argument("--smoothing-width", dest="smoothing_width",
+        type=int, default=0,
+        help="Smoothing kernel width. [0]")
+
+    # Outputs
+    output_args = parser.add_argument_group("Outputs")
+    output_args.add_argument("-o", "--outname", dest="outname",
+        type=str, required=True,
+        help="Output file.")
+    output_args.add_argument("-v", "--verbose", dest="verbose",
+        action="store_true",
+        help="Verbose mode.")
+    output_args.add_argument("-p", "--plot", dest="plot",
+        action="store_true",
+        help="Plot.")
+
+    return parser.parse_args(args=iargs)
+
+
+#################### MAIN ####################
+def main() -> None:
+    # Parse arguments
+    inps = cmd_parser()
+
+    # Read calendar years file
+    calyr, calpx, metadata = PDFs.readers.read_calendar_file(
+        fname=inps.date_fname,
+        name=inps.name,
+        variable_type=inps.variable_type,
+        unit=inps.input_unit,
+        verbose=inps.verbose,
+    )
+
+    # Convert calendar year to years before present (ypb)
+    if inps.verbose:
+        print(f"Shifting dates relative to reference: {inps.reference_date}")
+    ybp = inps.reference_date - calyr
+
+    # Scale from input units to output units
+    x = units.scale_values_by_units(
+        ybp, metadata["unit"], inps.output_unit, verbose=inps.verbose
+    )
+
+    # Flip left for right, so age is increasing
+    x = x[::-1]
+    px = calpx[::-1]
+
+    # Limit minimum age to zero
+    if inps.limit_zero:
+        # Non-negative indices
+        non_neg_ndx = (x >= 0)
+
+        # Crop arrays
+        x = x[non_neg_ndx]
+        px = px[non_neg_ndx]
+
+    # Form data into PDF
+    pdf = PDFs.PDF(
+        x=x,
+        px=px,
+        name=inps.name,
+        variable_type=inps.variable_type,
+        unit=inps.output_unit,
+    )
+
+    # Smooth data
+    if inps.smoothing_width > 0:
+        pdf = sampling.filtering.filter_pdf(
+            pdf=pdf,
+            filter_type=inps.smoothing_type,
+            filter_width=inps.smoothing_width,
+            edge_padding="zeros",
+            verbose=inps.verbose,
+        )
+
+    # Report final stats if requested
+    if inps.verbose:
+        PDFs.analytics.compute_pdf_statistics(pdf, verbose=True)
+
+    # Save to file
+    PDFs.readers.save_pdf(inps.outname, pdf, verbose=inps.verbose)
+
+    # Plot function if requested
+    if inps.plot:
+        # Initialize figure and axis
+        fig, (cal_ax, age_ax) = plt.subplots(nrows=2)
+
+        # Plot calendar years
+        cal_ax.plot(calyr, calpx, color="k")
+
+        # Plot PDF
+        plotting.plot_pdf_labeled(age_ax, pdf)
+
+        # Format plot
+        cal_ax.invert_xaxis()
+        cal_ax.set_xlabel("Calendar year (CE / BCE)")
+        cal_ax.set_ylabel("Probability density")
+
+        fig.tight_layout()
+
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()
+
+
+# end of file