Flux provides an elegant approach to machine learning. Written in Julia, it provides lightweight abstractions on top of Julia's native GPU and AD support. It has many useful tools built in, but also lets you use the full power of the Julia language where you need it. Flux has relatively few explicit APIs for features like regularization or embeddings; instead, writing down the mathematical form works and is fast. The package works well with Julia libraries from data frames and images to differential equation solvers, so building complex data processing pipelines that integrate Flux models is straightforward.

Swordfish studies the information yield of counting experiments. It implements at its core a rather general version of a Poisson point process with background uncertainties described by a Gaussian random field, and provides easy access to its information geometrical properties. Based on this information, a number of common and less common tasks can be performed. Swordfish allows quick and accurate forecasts of experimental sensitivities without time-intensive Monte Carlos, mock data generation and likelihood maximization. It can:

- calculate the expected upper limit or discovery reach of an instrument;
- derive expected confidence contours for parameter reconstruction;
- visualize confidence contours as well as the underlying information metric field;
- calculate the information flux, an effective signal-to-noise ratio that accounts for background systematics and component degeneracies; and
- calculate the Euclideanized signal which approximately maps the signal to a new vector which can be used to calculate the Euclidean distance between points.

Nauyaca infers planetary masses and orbits from mid-transit times fitting. The code requires transit ephemeris per planet and stellar mass and radius, and uses minimization routines and a Markov chain Monte Carlo method to find planet parameters that best reproduce the transit times based on numerical simulations. The code package provides customized plotting tools for analyzing the results.

GGCHEMPY is efficient for building 1-D, 2-D and 3-D simulations of physical parameters of Planck galactic cold clumps; it provides a graphical user interface and can also be invoked by a Python script. The code initializes the reaction network using input parameters, and then computes the reaction rate coefficients for all reactions. It uses the backward-differentiation formulas method to solve the ordinary differential equations for the integration. The modeled results are saved and can be directly passed to a Python dictionary for analysis and plotting.

The Julia library GRASS produces realistic stellar spectra with time-variable granulation signatures. It is based on real observations of the Sun, and does not rely on magnetohydrodynamic simulations to produce its spectra. GRASS can also compute bisectors for absorption lines or CCF profiles, and provides two methods for calculating bisectors.

BASTA determines properties of stars using a pre-computed grid of stellar models. It calculates the probability density function of a given stellar property based on a set of observational constraints defined by the user. BASTA is very versatile and has been used in a large variety of studies requiring robust determination of fundamental stellar properties.

Quokka is a two-moment radiation hydrodynamics code that uses the piecewise-parabolic method, with AMR and subcycling in time. It runs on CPUs (MPI+vectorized) or NVIDIA GPUs (MPI+CUDA) with a single-source codebase. The hydrodynamics solver is an unsplit method, using the piecewise parabolic method for reconstruction in the primitive variables, the HLLC Riemann solver for flux computations, and a method-of-lines formulation for the time integration. The order of reconstruction is reduced in zones where shocks are detected in order to suppress spurious oscillations in strong shocks. Quokka's radiation hydrodynamics formulation is based on the mixed-frame moment equations. The radiation subsystem is coupled to the hydrodynamic subsystem via operator splitting, with the hydrodynamic update computed first, followed by the radiation update, with the latter update including the source terms corresponding to the radiation four-force applied to both the radiation and hydrodynamic variables. A method-of-lines formulation is also used for the time integration, with the time integration done by the same integrator chosen for the hydrodynamic subsystem.

ParSNIP learns generative models of transient light curves from a large dataset of transient light curves. It is designed to work with light curves in sncosmo format using the lcdata package to handle large datasets. This code can be used for classification of transients, cosmological distance estimation, and identifying novel transients.

PISCOLA (Python for Intelligent Supernova-COsmology Light-curve Analysis) fits supernova light curves and corrects them in a few lines of code. It uses Gaussian Processes to estimate rest-frame light curves of transients without needing an underlying light-curve template. The user can add filters, calculates the light-curves parameters, and obtain transmission functions for the observed filters and the Bessell filters. The correction process can be applied with default settings to obtain restframe light curves and light-curve parameters. PISCOLA can plot the SN light curves, filter transmission functions, light-curves fits results, the mangling function for a given phase, and includes several utilities that can, for example, convert fluxes to magnitudes and magnitudes to fluxes, and trim leading and trailing zeros from a 1-D array or sequence.

ArtPop (Artificial Stellar Populations) synthesizes stellar populations and simulates realistic images of stellar systems. The code is modular, making it possible to use each of its functionalities independently or together. ArtPop can build stellar populations independently from generating mock images, as one might want to do when interested only in calculating integrated photometric properties of the population. The code can also generate stellar magnitudes and artificial galaxies, which can be inject into real imaging data.

TauRunner propagates ultra-high-energy neutrinos, with a focus on tau neutrinos. Although it was developed for extremely high energy (EeV+) applications, it is able to propagate neutrinos from 1 to 10^16 GeV. Oscillations are not taken into account at the lowest energies, but they become negligible above 1 TeV.

TULIPS (Tool for Understanding the Lives, Interiors, and Physics of Stars) creates diagrams of the structure and evolution of stars. It creates plots and movies based on output from the MESA stellar evolution code (ascl:1010.083). TULIPS represents stars as circles of varying size and color. The code can also visualize the size and perceived color of stars, their interior mixing and nuclear burning processes, their chemical composition, and can compare different MESA models.

PSRDADA supports the development of distributed data acquisition and analysis systems; it provides a flexible and well-managed ring buffer in shared memory with a variety of applications for piping data from device to ring buffer and from ring buffer to device. PSRDADA allows more than one data set to be queued in the ring buffer at one time, and data may be recorded in selected bursts using data validity flags. A variety of clients have been implemented that can write data to the ring buffer and read data from it. The primary write clients can be controlled via a simple, text-based socket interface, and read client software exists for writing data to an array of disks, sending data to an array of nodes, or processing the data directly from RAM. At the highest level of control and configuration, scripts launch the PSRDADA configuration across all nodes in the cluster, monitor all relevant processes, configure and control through a web-based interface, interface with observatory scheduling tools, and manage the ownership and archival of project data. It has been used in the implementation of baseband recording and processing instrumentation for radio pulsar astronomy.

Exodetbox provides mathematical methods for calculating the planet-star separation and difference in magnitude extrema as well as when planets have particular planet-star separations or differences in magnitude. The code also projects the 3D Keplerian Orbit into a reparameterized 2D ellipse in the plane of the sky. Exodetbox is implemented in the EXOSIMS modeling software (ascl:1706.010).

JWST_Simulation generates a novel geometric-focused deep field simulation of the expected JWST future deep field image. Galaxies are represented by ellipses with randomly-generated positions and orientations. Three scripts are included: a deterministic simulation, an ensemble simulation, and a more-realistic monochrome image simulation. The following initial conditions can be perturbed in these codes: H0, Ωm, ΩΛ, the dark energy equation of state parameter, the number of unseen galaxies in the Hubble Ultra Deep Field Image (HUDF), the increase in effective radius due to the JWST’s higher sensitivity, the anisotropy of dark energy, and the maximum redshift reached by the JWST. Galaxy number densities are estimated using integration over comoving volume with an integration constant calibrated with the Hubble Ultra Deep Field. A galaxy coverage percentage is calculated for each image to determine the percentage of the background occupied by galaxies.

Snowball models atmospheric loss in order to constrain an atmosphere's cumulative impact of historic X-ray and extreme ultraviolet radiation-driven mass loss. The escape model interpolates the BaSTI luminosity evolution grid to the observed mass and luminosity of the host star.

BiPoS1 (Binary Population Synthesizer) efficiently calculates binary distribution functions after the dynamical processing of a realistic population of binary stars during the first few Myr in the hosting embedded star cluster. It is particularly useful for generating a realistic birth binary population as an input for N-body simulations of globular clusters. Instead of time-consuming N-body simulations, BiPoS1 uses the stellar dynamical operator, which determines the fraction of surviving binaries depending on the binding energy of the binaries. The stellar dynamical operator depends on the initial star cluster density, as well as the time until the residual gas of the star cluster is expelled. At the time of gas expulsion, the dynamical processing of the binary population is assumed to effectively end due to the expansion of the star cluster related to that event. BiPoS1 has also a galactic-field mode, in order to synthesize the stellar population of a whole galaxy.

Healpix.jl is a Julia-only port of the C/C++/Fortran/Python HEALPix library (ascl:1107.018), which implements a hierarchical pixelization of the sphere in equal-area pixels. Much like the original library, Healpix.jl supports two enumeration schemes for the pixels (RING and NESTED) and implements an optimized computation of the generalized Fourier transform using spherical harmonics, binding libsharp2 (ascl:1402.033). In addition, Healpix.jl provides four additional features: 1.) it fully supports Windows systems, alongside the usual Linux and MAC OS X machines; 2.) it uses Julia's strong typesystem to prevent several bugs related to mismatches in map ordering (e.g., combining a RING map with a NESTED map); 3.) it uses a versatile memory layout so that map bytes can be stored in shared memory objects or on GPUs; and 4.) it implements an elegant and general way to signal missing values in maps.

OSPREI simulates the Sun-to-Earth (or satellite) behavior of CMEs. It is comprised of three separate models: ForeCAT, ANTEATR, and FIDO. ForeCAT uses the PFSS background to determine the external magnetic forces on a CME; ANTEATR takes the ForeCAT CME and propagates it to the final satellite distance, and outputs the final CME speed (both propagation and expansion), size, and shape (and their profiles with distance) as well as the arrival time and internal thermal and magnetic properties of the CME. FIDO takes the evolved CME from ANTEATR with the position and orientation from ForeCAT and passes the CME over a synthetic spacecraft. The relative location of the spacecraft within the CME determines the in situ magnetic field vector and velocity. It also calculates the Kp index from these values. OSPREI includes tools for creating figures from the results, including histograms, contour plots, and ensemble correlation plots, and new figures can be created using the results object that contains all the simulation data in an easily accessible format.

Varstar Detect uses several numerical and statistical methods to filter and interpret the data obtained from TESS. It performs an amplitude test to determine whether a star is variable and if so, provides the characteristics of each star through phenomenological analysis of the lightcurve.

Menura simulates the interaction between a fully turbulent solar wind and various bodies of the solar system using a novel two-step approach. It is an advanced numerical tool for self-consistent modeling that bridges planetary science and plasma physics. Menura is built around a hybrid Particle-In-Cell solver, treating electrons as a charge-neutralising fluid, and ions as massive particles. It solves iteratively the particles’ dynamics, gathers particle moments at the nodes of a grid, at which the magnetic field is also computed, and then solves the Maxwell equations. This solver uses the popular Current Advance Method (CAM).

BHJet models steady-state SEDs of jets launched from accreting black holes. This semi-analytical, multi-zone jet model is applicable across the entire black hole mass scale, from black hole X-ray binaries (both low and high mass) to active galactic nuclei of any class (from low-luminosity AGN to flat spectrum radio quasars). It is designed to be more comparable than other codes to GRMHD simulations and/or RMHD semi-analytical solutions.

gphist performs Bayesian inference on the cosmological expansion history using Gaussian process priors. It is written in Python and includes driver programs to run inference calculations and plot the results. The code infers the cosmological expansion history using a Gaussian process prior, reads these ouputs, and performs checks to ensure they are indeed compatible. gphist then generates a single combined output file to plot expansion history inferences.

ShapeMeasurementFisherFormalism is used to study Fisher Formalism predictions on galaxy weak lensing for LSST Dark Energy Science Collaboration. It can create predictions with user-defined parameters for one or two galaxies simulated from GalSim (ascl:1402.009).

WeakLensingDeblending provides weak lensing fast simulations and analysis for the LSST Dark Energy Science Collaboration. It is used to study the effects of overlapping sources on shear estimation, photometric redshift algorithms, and deblending algorithms. Users can run their own simulations (of LSST and other surveys) or download the galaxy catalog and simulation outputs to use with their own code.

SNEWPY uses simulated supernovae data to generate a time series of neutrino spectral fluences at Earth or the total time-integrated spectral fluence. The code can also process generated data through SNOwGLoBES (ascl:2109.019) and collate its output into the observable channels of each detector. Data from core-collapse, thermonuclear, and pair-instability supernovae simulations are included in the package.

SNOwGLoBES (SuperNova Observatories with GLoBES) computes interaction rates and distributions of observed quantities for supernova burst neutrinos in common detector materials. The code provides a very simple and fast code and data package for tests of observability of physics signatures in current and future detectors, and for evaluation of relative sensitivities of different detector configurations. The event estimates are made using available cross-sections and parameterized detector responses. Water, argon, scintillator and lead-based configurations are included. The package makes use of GLoBES (ascl:2109.018). SNOwGLoBES is not intended to replace full detector simulations; however output should be useful for many types of studies, and simulation results can be incorporated.

GLoBES simulates long baseline neutrino oscillation experiments. The package features full incorporation of correlations and degeneracies in the oscillation parameter space, advanced routines for the treatment of arbitrary systematical errors, and user-defined priors, which allowsn for the inclusion of arbitrary external physical information. Its use of AEDL, the Abstract Experiment Definition Language, provides an easy way to define experimental setups. GLoBES also provides an interface for the simulation of non-standard physics, and offers predefined setups for many experiments, including Superbeams, Beta Beams, Neutrino factories, Reactors, and various detector technologies.

HTOF parses the intermediate data from Hipparcos and Gaia and fits astrometric solutions to those data. It computes likelihoods and parameter errors in line with the catalog and can reproduce five, seven, and nine (or higher) parameter fits to their astrometry.

SkyPy simulates the astrophysical sky. It provides functions that sample realizations of sources and their associated properties from probability distributions. Simulation pipelines are constructed from these models, while task scheduling and data dependencies are handled internally. The package's modular design, containing a library of physical and empirical models across a range of observables and a command line script to run end-to-end simulations, allows users to interface with external software.

unpopular is an implementation of the Causal Pixel Model (CPM) de-trending method to obtain TESS Full-Frame Image (FFI) light curves. The code, written in Python, models the systematics in the light curves of individual pixels as a linear combination of light curves from many other distant pixels and removes shared flux variations. unpopular is able to preserve sector-length astrophysical signals, allowing for the extraction of multi-sector light curves from the FFI data.

The Hough Stream Spotter (HSS) is a stream finding code which transforms individual positions of stars to search for linear structure in discrete data sets. The code requires only the two-dimensional plane of galactic longitude and latitude as input.

WimPyDD calculates accurate predictions for the expected rates in WIMP direct–detection experiments within the framework of Galilean–invariant non–relativistic effective theory. The object–oriented customizable Python code handles different scenarios including inelastic scattering, WIMP of arbitrary spin, and a generic velocity distribution of WIMP in the Galactic halo.

STAR-MELT extracts and identifies emission lines from FITS files by matching to a compiled reference database of lines. Line profiles are fitted and quantified, allowing for calculations of physical properties across each individual observation. Temporal variations in lines can readily be displayed and quantified. STAR-MELT is also useful for different applications of spectral analysis where emission line identification is required. Standard data formats for spectra are automatically compatible, with user-defined custom formats also available. Any reference database (atomic or molecular) can also be used for line identification.

Rubble implicitly models the local evolution of dust distributions in size, mass, and surface density by solving the Smoluchowski equation (also known as the coagulation-fragmentation equation) under given disk conditions. The Python package's robustness has been validated by a suite of numerical benchmarks against known analytical and empirical results. Rubble can model prescribed physical processes such as bouncing, modulated mass transfer, regulated dust loss/supply, probabilistic collisional outcomes based on velocity distributions, and more. The package also includes a toolkit for analyzing and visualizing results produced by Rubble.

Frankenstein (frank) fits the 1D radial brightness profile of an interferometric source given a set of visibilities. It uses a Gaussian process that performs the fit in <1 minute for a typical protoplanetary disc continuum dataset. Frankenstein can perform a fit in 2 ways, by running the code directly from the terminal or using the code as a Python module.

pyFFTW is a pythonic wrapper around FFTW (ascl:1201.015), the speedy FFT library. Both the complex DFT and the real DFT are supported, as well as on arbitrary axes of arbitrary shaped and strided arrays, which makes it almost feature equivalent to standard and real FFT functions of numpy.fft. Additionally, it supports the clongdouble dtype, which numpy.fft does not, and operating FFTW in multithreaded mode.

pyia provides tools for working with Gaia data. It accesses Gaia data columns as Quantity objects, i.e., with units (e.g., data.parallax will have units ‘milliarcsecond’)
, constructs covariance matrices for Gaia data, and generates random samples from the Gaia error distribution per source. pyia can also create SkyCoord objects from Gaia data and execute simple (small) remote queries via the Gaia science archive and automatically fetch the results.

SkyCalc-iPy (SkyCalc for interactive Python) accesses atmospheric emission and transmission data generated by ESO’s SkyCalc tool interactively with Python. This package is based on the command line tool by ESO for accessing spectra on the ESO SkyCalc server.

The e-MERLIN CASA Pipeline calibrates and processes data from the e-MERLIN radio interferometer. It works on top of CASA (ascl:1107.013) and can convert, concatenate, prepare, flag and calibrate raw to produce advanced calibrated products for both continuum and spectral line data. The main outputs of the data are calibration tables, calibrated data, assessment plots, preliminary images of target and calibrator sources and a summary weblog. The pipeline provides an easy, ready-to-use toolkit that delivers calibrated data in a consistent, clear, and repeatable way. A parameters file is used to control the pipeline execution, so optimization of the algorithms is straightforward and reproducible. Good quality images are usually obtained with minimum human intervention.

SoFiA 2 is a fully automated spectral-line source finding pipeline originally intended for the detection of galaxies in large HI data cubes. It is a reimplementation of parts of the original SoFiA pipeline (ascl:1412.001) in the C programming language and uses OpenMP for multithreading, making it substantially faster and more memory-efficient than its predecessor. At its core, SoFiA 2 uses the Smooth + Clip algorithm for source finding which operates by spatially and spectrally smoothing the data on multiple scales and applying a user-defined flux threshold relative to the noise level in each iteration. A wide range of useful preconditioning and post-processing filters is available, including noise normalization, flagging of artifacts and reliability filtering. In addition to global data products and source catalogs in different formats, SoFiA 2 can also generate cutout images and spectra for each individual detection.

DviSukta calculates the Spherically Averaged Bispectrum (SABS). The code is based on an optimized direct estimation method, is written in C, and is parallelized. DviSukta starts by reading the real space gridded data and performing a 3D Fourier transform of it. Alternatively, it starts by reading the data already in Fourier space. The grid spacing, number of k1 bins, number of n bins, and number of cos(theta) bins need to be specified in the input file.

The VOLK2 (VLBI Observation for transient Localization Keen Searcher) pipeline conducts single pulse searches and localization in regular VLBI observations as well as single pulse detections from known sources in dedicated observations. In VOLKS2, the search and localization are two independent steps. The search step takes the idea of geodetic VLBI post processing, which fully utilizes the cross spectrum fringe phase information to maximize the signal power. Compared with auto spectrum based method, it is able to extract single pulses from highly RFI contaminated data. The localization uses the geodetic VLBI solving methods, which derives the single pulse location by solving a set of linear equations given the relation between the residual delay and the offset to a priori position.

alpconv calculates the alp-photon conversion by calculating the degree of irregularity of the spectrum, in contract to some other methods that fit the source's spectrum with both null and ALP models and then compare the goodness of fit between the two.

gammaALPs calculates the conversion probability between photons and axions/axion-like particles in various astrophysical magnetic fields. Though focused on environments relevant to mixing between gamma rays and ALPs, this suite, written in Python, can also be used for broader applications. The code also implements various models of astrophysical magnetic fields, which can be useful for applications beyond ALP searches.

A super lightweight interface in Python to load spectra from the Pickles 1998 (stellar) and Brown 2014 (galactic) spectral catalogues

A python package created around Eric Gendron’s code for analytically (and quickly) generating field-varying SCAO PSFs for the ELT.

A reference database for astronomical instrument and telescope characteristics for all types of visual and infrared systems. Instrument packages are used in conjunction with the ScopeSim instrument data simulator.

Templates and helper functions for creating on-sky Source description objects for the ScopeSim instrument data simulation engine.

An attempt at creating a common pythonic framework for visual and infrared telescope instrument data simulators.