pycosie is analysis code used for Technicolor Dawn (TD), a Gadget-3 derived cosmological radiative SPH simulation suite. The target analyses are to complement what is done with TD and other analysis software in its suite. pycosie creates power spectrum from generated Lyman-alpha forests spectra, links absorbers to potential host galaxies, grids gas information for each galaxy, and reads specific output files from software such as Rockstar (ascl:1210.008) and SKID (ascl:1102.020).

Python Fully Automated TiRiFiC (pyFAT) wraps around the tilted ring fitting code (TiRiFiC, ascl:1208.008) to fully automate the process of fitting simple tilted ring models to line emission cubes. pyFAT is the successor to the IDL/GDL FAT (ascl:1507.011) code and offers improved handling and fitting as well as several new features. PyFAT fits simple rotationally symmetric discs with asymmetric warps and surface brightness distributions, providing a base model that can can be used in TiRiFiC to explore large scale motions. pyFAT delivers much more control over the fitting procedure, which is made possible by the new modular setup and the use of omegaconf for the input and default settings.

MAKEE (MAuna Kea Echelle Extraction) reduces data from the HIRES and ESI instruments at Keck Observatory. It is optimized for the spectral extraction of single, unresolved point sources and is designed to run non-interactively using a set of default parameters. Taking the raw HIRES FITS files as input, the code determines the position (or trace) of each echelle order, defines the object and background extraction boundaries, optimally extracts a spectrum for each order, and computes wavelength calibrations. MAKEE produces FITS format "spectral images" (each row is a separate echelle order spectrum) and the data values are in arbitrary (relative) flux units. MAKEE will reduce data from all HIRES formats, including the single CCD format, the single CCD with Red and UV cross dispersers, and the current 3 CCD system. It can handle a variety of pixel binnings, including 1x1, 1x2, 1x4 (column x row).

WinNet, a single zone nuclear reaction network, calculates many different nucleosynthesis processes, including r-process, nup-process, and explosive nucleosynthesis, and many more). It reads in a user-defined file with runtime parameters, then chooses the evolution mode, which is dependent on temperature. The temperature, density, and neutrino quantities are updated, after which the reaction network equations are solved numerically. If convergence is not achieved, the step size is halved and the iteration is repeated. Once convergence is reached, the output is generated and the time is evolved; the final output such as the final abundances and mass fractions are written.

Exovetter is an open-source, pip-installable python package which calculates metrics on high cadence time series photometry to distinguish between exoplanet transit signals and false positives. The package standardizes the implementation of metrics developed for the TESS, Kepler, and K2 missions such as Odd-Even, Multiple Event Statistic, and Centroid Offset (see “Planetary Candidates Observed by Kepler. VIII.”, Thompson et al. 2018.). Metrics can be run individually or together as part of a pipeline. Exovetter also includes several visualizations to further evaluate the transits and metrics.

AutoPhOT (AUTOmated Photometry Of Transients) produces publication-quality photometry of transients quickly. Written in Python 3, this automated pipeline's capabilities include aperture and PSF-fitting photometry, template subtraction, and calculation of limiting magnitudes through artificial source injection. AutoPhOT is also capable of calibrating photometry against either survey catalogs (e.g., SDSS, PanSTARRS) or using a custom set of local photometric standards.

Redback provides end-to-end interpretation and parameter estimation of electromagnetic transients. Using data downloaded by the code or provided by the user, the code processes the data into a homogeneous transient object. Redback implements several different types of electromagnetic transients models, ranging from simple analytical models to numerical surrogates, fits models implemented in the package or provided by the user, and plots lightcurves. The code can also be used as a tool to simulate realistic populations without having to fit anything, as models are implemented as functions and can be used to simulate populations. Redback uses Bilby (ascl:1901.011) for sampling and can easily switch samplers and likelihoods.

The phi-GPU (Parallel Hermite Integration on GPU) high-order N-body parallel dynamic code uses the fourth-order Hermite integration scheme with hierarchical individual block time-steps and incorporates external gravity. The software works directly with GPU, using only NVIDIA GPU and CUDA code. It creates numerical simulations and can be used to study galaxy and star cluster evolution.

Faceted-HyperSARA images radio-interferometric wideband intensity data. Written in MATLAB, the library offers a collection of utility functions and scripts from data extraction from an RI measurement set MS Table to the reconstruction of a wideband intensity image over the field of view and frequency range of interest. The code achieves high precision imaging from large data volumes and supports data dimensionality reduction via visibility gridding and estimation of the effective noise level when reliable noise estimates are not available. Faceted-HyperSASA also corrects the w-term via w-projection and incorporates available compact Fourier models of the direction dependent effects (DDEs) in the measurement operator.

PowerSpecCovFFT computes the non-Gaussian (regular trispectrum and its shot noise) part of the analytic covariance matrix of the redshift-space galaxy power spectrum multipoles using an FFTLog-based method. The galaxy trispectrum is based on a tree-level standard perturbation theory but with a slightly different galaxy bias expansion. The code computes the non-Gaussian covariance of the power spectrum monopole, quadrupole, hexadecapole, and their cross-covariance up to kmax ~ 0.4 h/Mpc.

GRINN (Gravity Informed Neural Network) solves the coupled set of time-dependent partial differential equations describing the evolution of self-gravitating flows in one, two, and three spatial dimensions. It is based on physics informed neural networks (PINNs), which are mesh-free and offer a fundamentally different approach to solving such partial differential equations. GRINN has solved for the evolution of self-gravitating, small-amplitude perturbations and long-wavelength perturbations and, when modeling 3D astrophysical flows, provides accuracy on par with finite difference (FD) codes with an improvement in computational speed.

This python code automatically detects solar active regions (AR). Based on morphological operation and region growing, it uses synoptic magnetograms from SOHO/MDI and SDO/HMI and calculates the parameters that characterize each AR, including the latitude and longitude of the flux-weighted centroid of two polarities and the whole AR, the area, and the flux of each polarity, and the initial and final dipole moments.

Phazap post-processes gravitational-wave (GW) parameter estimation data to obtain the phases and polarization state of the signal at a given detector and frequency. It is used for low-latency identification of strongly lensed gravitational waves via their phase consistency by measuring their distance in the detector phase space. Phazap builds on top of the IGWN conda enviroment which includes the standard GW packages LALSuite (ascl:2012.021) and bilby (ascl:1901.011), and can be applied beyond lensing to test possible deviations in the phase evolution from modified theories of gravity and constrain GW birefringence.

Photochem models the photochemical and climate composition of a planet's atmosphere. It takes inputs such as the stellar UV flux and atmospheric temperature structure to find the steady-state chemical composition of an atmosphere, or evolve atmospheres through time. Photochem also contains 1-D climate models and a chemical equilibrium solver.

LeHaMoC simulates high-energy astrophysical sources. It simulates the behavior of relativistic pairs, protons interacting with magnetic fields, and photons in a spherical region. The package contains numerous physical processes, including synchrotron emission and self-absorption, inverse Compton scattering, photon-photon pair production, and adiabatic losses. It also includes proton-photon pion production, proton-photon (Bethe-Heitler) pair production, and proton-proton collisions. LeHaMoC can model expanding spherical sources with a variable magnetic field strength. In addition, three types of external radiation fields can be defined: grey body or black body, power-law, and tabulated.

Magnification bias estimation estimates magnification bias for a galaxy sample with a complex photometric selection for the example of SDSS BOSS. The code works for CMASS and the LOWZ, z1 and z3 samples. A template for applying the approach to other surveys is included; requirements include a galaxy catalog that provides magnitudes (used for photometric selection) and the exact conditions used for the photometric selection.

SuperLite produces synthetic spectra for astrophysical transient phenomena affected by circumstellar interaction. It uses Monte Carlo methods and multigroup structured opacity calculations for semi-implicit, semirelativistic radiation transport in high-velocity shocked outflows, and can reproduce spectra of typical Type Ia, Type IIP, and Type IIn supernovae. SuperLite also generates high-quality spectra that can be compared with observations of transient events, including superluminous supernovae, pulsational pair-instability supernovae, and other peculiar transients.

ytree reads and works with merger tree data from multiple formats. An extension of yt (ascl:1011.022), which can analyze snapshots from cosmological simulations, ytree can be thought of as the yt of merger trees. ytree's online documentation lists supported formats; support for additional formats can be added, as in principle, any type of tree-like data where an object has one or more ancestors and a single descendant can be supported.

BiaPy provides deep-learning workflows for a large variety of image analysis tasks, including 2D and 3D semantic segmentation, instance segmentation, object detection, image denoising, single image super-resolution, self-supervised learning and image classification. Though developed specifically for bioimages, it can be used for watershed-based instance segmentation for friends-of-friends proto-haloes.

FLORAH generates the assembly history of halos using a recurrent neural network and normalizing flow model. The machine-learning framework can be used to combine multiple generated networks that are trained on a suite of simulations with different redshift ranges and mass resolutions. Depending on the training, the code recovers key properties, including the time evolution of mass and concentration, and galaxy stellar mass versus halo mass relation and its residuals. FLORAH also reproduces the dependence of clustering on properties other than mass, and is a step towards a machine learning-based framework for planting full merger trees.

EVA (Excess Variability-based Age) computes the VarX values and VarX90 ages for a given list of stars. The package retrieves information from Gaia, performs basic var90 calculations, then calculates the age of the group in a given band or overall (by combining all three bands). EVA then analyzes and plots the results.

The ALeRCE anomaly detector cross-validates six anomaly detection algorithms for three classes (transient, periodic, and stochastic) of anomalous sources within the Zwicky Transient Facility (ZTF) data stream using the ALeRCE light curve features. A machine and deep learning-based framework is used for anomaly detection. For each class, a distinct anomaly detection model is constructed using only information about the known objects (i.e., inliers) for training. An anomaly score is computed using the probabilities to determine whether the light curve corresponds to a transient, stochastic, or periodic nature.

Quadratic Monte Carlo generates ensembles of models and confines fitness landscapes without relying on linear stretch moves; it works very efficiently for ring potential and Rosenbrock density. The method is general and can be implemented into any existing MC software, requiring only a few lines of code.

Color transformations calculator determines the magnitude of a galaxy in a needed photometric band, given its color and magnitude in the original band. It supports various optical and near intrared surveys, including SDSS, DECaLS, DELVE, UKIDSS, VHS, and VIKING, and provides conversions for both total and aperture magnitudes with apertures of 1.5", 2" or 3" diameters. The source code, useful for performing bulk calculations, is available in Python and IDL; the calculator is also offered as a web service.

PRyMordial offers fast and precise evaluation of both the Big Bang Nucleosynthesis (BBN) light-element abundances and the effective number of relativistic degrees of freedom. It can be used within and beyond the Standard Model. The package calculates N_eff and helium-4, deuterium, helium-3 and lithium-7 abundances. PRyMordial corrects for QED plasma effects, neutron lifetime, and incomplete neutrino decoupling, and includes an optional module that re-elaborates all the ODE systems of the code in Julia.

CBiRd (Code for Bias tracers In Redshift space) provides correlators in the Effective Field Theory of Large-Scale Structure (EFTofLSS) in a ready-to-use pipeline for cosmological analysis of galaxy-redshift surveys data. It provides a core calculation package (C++BiRd), a Python implementation of a Taylor expansion of the power spectrum around a reference cosmology for efficient evaluation (TBiRd), and libraries to correct for observational systematics. CBiRd also provides MCMC samplers (MCBiRd) for a power spectrum and bispectrum analysis of galaxy-redshift surveys data based on emcee (ascl:1303.002), and can provide an earlybird pass to explore the cosmos with LSS surveys.

sphereint calculates the numerical volume in a sphere. It provides a weight for each grid position based on whether or not it is in (weight = 1), out (weight = 0), or partially in (weight in between 0 and 1) a sphere of a given radius. A cubic cell is placed around each grid position and the volume of the cell in the sphere (assuming a flat surface in the cell) is calculated and normalized by the cell volume to obtain the weight.

CARDiAC (Code for Anisotropic Redshift Distributions in Angular Clustering) computes the impact of anisotropic redshift distributions on a wide class of angular clustering observables. It supports auto- and cross-correlations of galaxy samples and cosmic shear maps, including galaxy-galaxy lensing. The anisotropy can be present in the mean redshift and/or width of Gaussian distributions, as well as in the fraction of galaxies in each component of multi-modal distributions. Templates of these variations can be provided by the user or simulated internally within the code.

The anzu package offers two independent codes for hybrid Lagrangian bias models in large-scale structure. The first code measures the hybrid "basis functions"; the second takes measurements of these basis functions and constructs an emulator to obtain predictions from them at any cosmology (within the bounds of the training set). anzu is self-contained; given a set of N-body simulations used to build emulators, it measures the basis functions. Alternatively, given measurements of the basis functions, anzu should in principle be useful for constructing a custom emulator.

Lenser estimates weak gravitational lensing signals, particularly flexion, from real survey data or realistically simulated images. Lenser employs a hybrid of image moment analysis and an Analytic Image Modeling (AIM) analysis. In addition to extracting flexion measurements by fitting a (modified Sérsic) model to a single image of a galaxy, Lenser can do multi-band, multi-epoch fitting. In multi-band mode, Lenser fits a single model to multiple postage stamps, each representing an exposure of a single galaxy in a particular band.

candl (CMB Analysis With A Differentiable Likelihood) analyzes CMB power spectrum measurements using a differentiable likelihood framework. It is compatible with JAX (ascl:2111.002), though JAX is optional, allowing for fast and easy computation of gradients and Hessians of the likelihoods, and candl provides interface tools for working with other cosmology software packages, including Cobaya (ascl:1910.019) and MontePython (ascl:1805.027). The package also provides auxiliary tools for common analysis tasks, such as generating mock data, and supports the analysis of primary CMB and lensing power spectrum data.

SMART (Spectral energy distributions Markov chain Analysis with Radiative Transfer models) implements a Bayesian Markov chain Monte Carlo (MCMC) method to fit the ultraviolet to millimeter spectral energy distributions (SEDs) of galaxies exclusively with radiative transfer models. The models constitute four types of pre-computed libraries, which describe the starburst, active galactic nucleus (AGN) torus, host galaxy and polar dust components.

Scaling Relations Finder finds the scaling relations between magnetic field properties and observables for a model of galactic magnetic fields. It uses observable quantities as input: the galaxy rotation curve, the surface densities of the gas, stars and star formation rate, and the gas temperature to create galactic dynamo models. These models can be used to estimate parameters of the random and mean components of the magnetic field, as well as the gas scale height, root-mean-square velocity and the correlation length and time of the interstellar turbulence, in terms of the observables.

GAStimator implements a Python MCMC Gibbs-sampler with adaptive stepping. The code is simple, robust, and stable and well suited to high dimensional problems with many degrees of freedom and very sharp likelihood features. It has been used extensively for kinematic modeling of molecular gas in galaxies, but is fully general and may be used for any problem MCMC methods can tackle.

CosmoPower develops Bayesian inference pipelines that leverage machine learning to solve inverse problems in science. While the emphasis is on building algorithms to accelerate Bayesian inference in cosmology, the implemented methods allow for their application across a wide range of scientific fields. CosmoPower provides neural network emulators of matter and Cosmic Microwave Background power spectra, which can replace Boltzmann codes such as CAMB (ascl:1102.026) or CLASS (ascl:1106.020) in cosmological inference pipelines, to source the power spectra needed for two-point statistics analyses. This provides orders-of-magnitude acceleration to the inference pipeline and integrates naturally with efficient techniques for sampling very high-dimensional parameter spaces.

ndcube manipulates, inspects, and visualizes multi-dimensional contiguous and non-contiguous coordinate-aware data arrays. A sunpy (ascl:1401.010) affiliated package, it combines data, uncertainties, units, metadata, masking, and coordinate transformations into classes with unified slicing and generic coordinate transformations and plotting and animation capabilities. ndcube handles data of any number of dimensions and axis types (e.g., spatial, temporal, and spectral) whose relationship between the array elements and the real world can be described by World Coordinate System (WCS) translations.

raccoon implements the cross-correlation function (CCF) method. It builds weighted binary masks from a stellar spectrum template, computes the CCF of stellar spectra with a mask, and derives radial velocities (RVs) and activity indicators from the CCF. raccoon is mainly implemented in Python 3; it also uses some Fortran subroutines that are called from Python.

blackthorn generates spectra of dark matter annihilations into right-handed (RH) neutrinos or into particles that result from their decay. These spectra include photons, positrons, and neutrinos. The code provides support for varied RH-neutrino masses ranging from MeV to TeV by incorporating hazma, PPPC4DMID, and HDMSpectra models to compute dark matter annihilation cross sections and mediator decay widths. blackthorn also computes decay branching fractions and partial decay widths.

PALpy provides a Python interface to PAL, the positional Astronomy Library (ascl:1606.002), which is written in C. All arguments modified by the C API are returned and none are modified. The one routine that is different is palObs, which returns a simple dict that can be searched using standard Python. The keys to the dict are the short names and the values are another dict with keys name, long, lat and height.

tapify implements a suite of multitaper spectral estimation techniques for analyzing time series data. It supports analysis of both evenly and unevenly sampled time series data. The multitaper statistic tackles the problems of bias and consistency, which makes it an improvement over the classical periodogram for evenly sampled data and the Lomb-Scargle periodogram for uneven sampling. In basic statistical terms, this estimator provides a confident look at the properties of a time series in the frequency or Fourier domain.

coronagraph provides a Python noise model for directly imaging exoplanets with a coronagraph-equipped telescope. Based on the original IDL code for this coronagraph model, coronograph_noise (ascl:2405.018), the Python version has been expanded in a few key ways. Most notably, the Telescope, Planet, and Star objects used for reflected light coronagraph noise modeling can now be used for transmission and emission spectroscopy noise modeling, making this model a general purpose exoplanet noise model for many different types of observations.

coronagraph_noise simulates coronagraph noise. Written in IDL, the code includes a generalized coronagraph routine and simulators for the WFIRST Shaped Pupil Coronagraph in both spectroscopy and imaging modes. Functions available include stellar and planetary flux functions, planet photon and zodiacal light count rates, planet-star flux ratio, and clock induced charge count rate, among others. coronagraph_noise also includes routines to smooth a plot by convolving with a Gaussian profile to convolve a spectrum with a given instrument resolution and to take a spectrum that is specified at high spectral resolution and degrade it to a lower resolution. A Python implementation of coronagraph_noise, coronagraph (ascl:2405.019), is also available.

AFINO (Automated Flare Inference of Oscillations) finds oscillations in time series data using a Fourier-based model comparison approach. The code analyzes the date and generates a results file in either JSON or Pickle format, which contains numerous properties of the data and analysis, and a summary plot.

autoregressive-bbh-inference, written in Python, models the distributions of binary black hole masses, spins, and redshifts to identify physical features appearing in these distributions without the need for strongly-parametrized population models. This allows not only agnostic study of the “known unknowns” of the black hole population but also reveals the “unknown unknowns," the unexpected and impactful features that may otherwise be missed by the standard building-block method.

sunbather simulates the upper atmospheres of exoplanets and their observational signatures. The code constructs 1D Parker wind profiles using p-winds (ascl:2111.011) to simulate these with Cloudy (ascl:9910.001), and postprocesses the output with a custom radiative transfer module to predict the transmission spectra of exoplanets.

EF-TIGRE (Effective Field Theory of Interacting dark energy with Gravitational REdshift) constrains interacting Dark Energy/Dark Matter models in the Effective Field Theory framework through Large Scale Structures observables. In particular, the observables include the effect of gravitational redshift, a distortion of time from galaxy clustering. This generates a dipole in the correlation function which is detectable with two distinct populations of galaxies, thus making it possible to break degeneracies among parameters of the EFT description.

LTdwarfIndices studies spectral indices to determine whether one or more brown dwarfs are photometric variable candidates. For a single brown dwarf, it analyzes a given set of indices and outputs the number of graphs the object appears in in the variable area, whether it is a variable or non-variable candidate, and, optionally, an index-index or histogram plot. Using another code module, LTdwarftIndices can also analyze a set of sample indices for many brown dwarfs.

fitramp fits a ramp to a series of nondestructive reads and detects and rejects jumps. The software performs likelihood-based jump detection for detectors read out up-the-ramp; it uses the entire set of reads to compute likelihoods. The code compares the χ² value of a fit with and without a jump for every possible jump location. fitramp can fit ramps with and without fitting the reset value (the pedestal), and fit and mask jumps within or between groups of reads. It can also compute the bias of ramp fitting.

DirectSHT performs direct spherical harmonic transforms for point sets on the sphere. Given a set of points, defined by arrays of theta and phi (in radians) and weights, it provides the spherical harmonic transform coefficients alm. JAX (ascl:2111.002) can be used to speed up the computation; the code will automatically fall back to numpy if JAX is not present. The code is much faster when run on GPUs. When they are available and JAX is installed, the code automatically distributes computation and memory across them.

riddler automates fitting of type Ia supernovae spectral time series. The code is comprised of a series of neural networks trained to emulate radiative transfer simulations from TARDIS (ascl:1402.018). Emulated spectra are then fit to observations using nested sampling implemented in UltraNest (ascl:1611.001) to estimate the posterior distributions of model parameters and evidences.

morphen performs image analysis, multi-Sersic image fitting decomposition, and radio interferometric self-calibration, thus measuring basic image morphology and photometry. The code provides a state-of-the-art Python-based image fitting implementation based on the Sersic function. Geared, though not exclusively, toward radio astronomy, morphen's tools involve pure python, but also are integrated with CASA (ascl:1107.013) in order to work with common casatasks as well as WSClean (ascl:1408.023).

i-SPin simulates 3-component Schrodinger systems with and without gravity and with and without self-interactions while obeying SO(3) symmetry. The code allows the user to input desired parameters, along with initial conditions for the Schrodinger fields. Its three function modules then perform the main (drift-kick-drift) steps of the algorithm, track the fractional changes in total mass and spin in the system, and then plot results. The default plots are mass and spin density projections along with total mass and spin fractional changes.

GauPro fits a Gaussian process regression model to a dataset. A Gaussian process (GP) is a commonly used model in computer simulation. It assumes that the distribution of any set of points is multivariate normal. A major benefit of GP models is that they provide uncertainty estimates along with their predictions.

ICPertFLRW, a Cactus code (ascl:1102.013) thorn, provides as initial conditions an FLRW metric perturbed with the comoving curvature perturbation Rc in the synchronous comoving gauge. Rc is defined as a sum of sinusoidals (20 in each x, y, and z direction) whose amplitude, wavelength, and phase shift are all parameters in param.ccl. While the metric and extrinsic curvature only have first order scalar perturbations, the energy density is computed exactly in full from the Hamiltonian constraint, hence vector and tensor perturbations are initially present at higher order. These are then passed to the CT_Dust thorn to be evolved.

pySPEDAS (Python-based Space Physics Environment Data Analysis Software) supports multi-mission, multi-instrument retrieval, analysis, and visualization of heliophysics time series data. A Python implementation of SPEDAS (ascl:2405.001), it supports most of the capabilities of SPEDAS; it can load heliophysics data sets from more than 30 space-based and ground-based missions, coordinate transforms, interpolation routines, and unit conversions, and provide interactive access to numerous data sets. pySPEDAS also creates multi-mission, multi-instrument figures, includes field and wave analysis tools, and performs magnetic field modeling, among other functions.

pyADfit models accretion discs around astrophysical objects. The code provides functions to calculate physical quantities related to accretion disks and perform parameter estimation using observational data. The accretion disc model is the alpha-disc model while the parameter estimation can be performed with Nessai (ascl:2405.002), Raynest (ascl:2405.003), or CPnest (ascl:2205.021).

raynest, written in Python, computes Bayesian evidences and probability distributions using parallel chains.

nessai performs nested sampling for Bayesian Inference and incorporates normalizing flows. It is designed for applications where the Bayesian likelihood is computationally expensive. nessai uses PyTorch and also supports the use of bilby (ascl:1901.011).

The SPEDAS (Space Physics Environment Data Analysis Software) framework supports multi-mission data ingestion, analysis and visualization for the Space Physics community. It standardizes the retrieval of data from distributed repositories, the scientific processing with a powerful set of legacy routines, the quick visualization with full output control and the graph creation for use in papers and presentations. SPEDAS includes a GUI for ease of use by novice users, works on multiple platforms, and though based on IDL, can be used with or without an IDL license. The framework supports plugin modules for multiple projects such as THEMIS, MMS, and WIND, and provides interfaces for software modules developed by the individual teams of those missions. A Python implementation of the framework, PySPEDAS (ascl:2405.005), is also available.

Swiftest is a software package designed to model the long-term dynamics of system of bodies in orbit around a dominant central body, such a planetary system around a star, or a satellite system around a planet. The main body of the program is written in Modern Fortran, taking advantage of the object-oriented capabilities included with Fortran 2003 and the parallel capabilities included with Fortran 2008 and Fortran 2018. Swiftest also includes a Python package that allows the user to quickly generate input, run simulations, and process output from the simulations. Swiftest uses a NetCDF output file format which makes data analysis with the Swiftest Python package a streamlined and flexible process for the user. Building off a strong legacy, including its predecessors Swifter and Swift, Swiftest takes the next step in modeling the dynamics of planetary systems by improving the performance and ease of use of software, and by introducing a new collisional fragmentation model. Currently, Swiftest includes the four main symplectic integrators included in its predecessors: WHM, RMVS, HELIO, and SyMBA. In addition, Swiftest also contains the Fraggle model for generating products of collisional fragmentation.

We present a module built into the PypeIt Python package to reduce high resolution Y, J, H, K, and L band spectra from the W. M. Keck Observatory NIRSPEC spectrograph. This data reduction pipeline is capable of spectral extraction, wavelength calibration, and telluric correction of data taken before and after the 2018 detector upgrade, all in a single package. The procedure for reducing data is thoroughly documented in an expansive tutorial.

A fast GPU-based bispectrum estimator implemented using JAX.

RhoPop identifies compositionally distinct populations of small planets (R≲2R_⊕). It employs mixture models in a hierarchical framework and the dynesty (ascl:1809.013) nested sampler for parameter and evidence estimates. RhoPop includes a density-mass grid of water-rich compositions from water mass fraction (WMF) 0-1.0 and a grid of volatile-free rocky compositions over a core mass fraction (CMF) range of 0.006-0.95. Both grids were calculated using the ExoPlex mass-radius-composition calculator (ascl:2404.029).

ExoPlex is a thermodynamically self-consistent mass-radius-composition calculator. Users input a bulk molar composition and a mass or radius, and ExoPlex will calculate the resulting radius or mass. Additionally, it will produce the planet's core mass fraction, interior mineralogy and the pressure, adiabatic temperature, gravity and density profiles as a function of depth.

binary_precursor models light curves of supernova (SN) precursors powered by a pre-SN outburst accompanying accretion onto a compact object companion. Though it is only one of the possible models, it is useful for interpretations of (bright) SN precursors highly exceeding the Eddington limit of massive stars, which are observed in a fraction of SNe with dense circumstellar matter (CSM) around the progenitor. It offers a number of editable parameters, including compact object mass, progenitor mass, progenitor radii, and opacity. Initial CSM velocity can be normalized by the progenitor escape velocity (xi parameter), and the CSM mass, ionization temperature, and binary separation can also be specified.

S2FFT computes Fourier transforms on the sphere and rotation group using JAX (ascl:2111.002) or PyTorch. It leverages autodiff to provide differentiable transforms, which are also deployable on hardware accelerators (e.g., GPUs and TPUs). More specifically, S2FFT provides support for spin spherical harmonic and Wigner transforms (for both real and complex signals), with support for adjoint transformations where needed, and comes with different optimisations (precompute or not) that one may select depending on available resources and desired angular resolution L.

LEO-vetter automatically vets transit signals found in light curve data. Inspired by the Kepler Robovetter (ascl:2012.006), LEO-vetter computes vetting metrics to be compared to a series of pass-fail thresholds. If a signal passes all tests, it is considered a planet candidate (PC). If a signal fails at least one test, it may be either an astrophysical false positive (FP; e.g., eclipsing binary, nearby eclipsing signal) or false alarm (FA; e.g., systematic, stellar variability). Pass-fail thresholds can be changed to suit individual research purposes, and LEO-vetter produces vetting reports for manual inspection of signals. Flux-level vetting can be applied to any light curve dataset (such as Kepler, K2, and TESS), including light curves with mixes of cadences, while pixel-level vetting has been implemented for TESS.

stringgen creates emulations of cosmic string maps with statistics similar to those of a single (or small ensemble) of reference simulations. It uses wavelet phase harmonics to calculate a compressed representation of these reference simulations, which may then be used to synthesize new realizations with accurate statistical properties, e.g., 2 and 3 point correlations, skewness, kurtosis, and Minkowski functionals.

Written in Python, pAGN solves AGN disk model equations. The code is highly customizable and, with the correct inputs, provides a fully evolved AGN disk model through parametric 1D curves for key disk parameters such as temperature and density. pAGN can be used to study migration torques in AGN disks, simulations of compact object formation inside gas disks, and comparisons with new, more complex models of AGN disks.

mhealpy extends the functionalities of the HEALPix (ascl:1107.018) wrapper healpy (ascl:2008.022) to handle single and multi-resolution maps (a.k.a. multi-order coverage maps or MOC maps). In addition to creating and analyzes MOC maps, it supports arithmetic operations, adaptive grids, resampling of existing multi-resolution maps, and plotting, among other functions, and reads and writes to FITS, which enables sharing spatial information for multiwavelength and multimessenger analyses.

jetsimpy creates hydrodynamic simulations of relativistic blastwaves with tabulated angular energy and Lorentz factor profiles and efficiently models Gamma-Ray Burst afterglows. It supports tabulated angular energy and tabulated angular Lorentz factor profiles. jetsimpy also supports ISM, wind, and mixed external density profile, including synthetic afterglow light curves, apparent superluminal motion, and sky map and Gaussian equivalent image sizes. Additionally, you can add your own emissivity model by defining a lambda function in a c++ source file, allowing the package to be used for more complicated models such as Synchrotron self-absorption.

cuDisc simulates the evolution of protoplanetary discs in both the radial and vertical dimensions, assuming axisymmetry. The code performs 2D dust advection-diffusion, dust coagulation/fragmentation, and radiative transfer. A 1D evolution model is also included, with the 2D gas structure calculated via vertical hydrostatic equilibrium. cuDisc requires a NVIDIA GPU.

NbodyIMRI uses N-body simulations to study Dark Matter-dressed intermediate-mass ratio inspirals (IMRI) and extreme mass ratio inspiral (EMRI) systems. The code calculates all BH-BH forces and BH-DM forces directly while neglecting DM-DM pairwise interactions. This allows the code to scale up to very large numbers of DM particles in order to study stochastic processes like dynamical friction.

PySSED (Python Stellar Spectral Energy Distributions) downloads and extracts data on multi-wavelength catalogs of astronomical objects and regions of interest and automatically proceses photometry into one or more stellar SEDs. It then fits those SEDs with stellar parameters. PySSED can be run directly from the command line or as a module within a Python environment. The package offers a wide variety plots, including Hertzsprung–Russell diagrams of analyzed objects, angular separation between sources in specific catalogs, and two-dimensional offset between cross-matches.

GPUniverse models quantum fields in finite dimensional Hilbert spaces with Generalised Pauli Operators (GPOs) and overlapping degrees of freedom. In addition, the package can simulate sets of qubits that are only quasi independent (i.e., the Pauli algebras of different qubits have small, but non-zero anti-commutator), which is useful for validating analytical results for holographic versions of the Weyl field.

pyilc implements the needlet internal linear combination (NILC) algorithm for CMB component separation in pure Python; it also implements harmonic-space ILC. The code can also perform Cross-ILC, where the covariance matrices are computed only from independent splits of the maps. In addition, pyilc includes an inpainting code, diffusive_inpaint, that diffusively inpaints a masked region with the mean of the unmasked neighboring pixels.

The Machine Learning Telescope Pointing Correction code trains and tests machine learning models for correcting telescope pointing. Using historical APEX data from 2022, including pointing corrections, and other data such as weather conditions, position and rotation of the secondary mirror, pointing offsets observed during pointing scans, and the position of the sun, among other data, the code treats the data in two different ways to test which factors are the most likely to account for pointing errors.

EBWeyl computes the electric and magnetic parts of the Weyl tensor, Eαβ and Bαβ, using a 3+1 slicing formulation. The module provides a Finite Differencing class with 4th (default) and 6th order backward, centered, and forward schemes. Periodic boundary conditions are used by default; otherwise, a combination of the 3 schemes is available. It also includes a Weyl class that computes for a given metric the variables of the 3+1 formalism, the spatial Christoffel symbols, spatial Ricci tensor, electric and magnetic parts of the Weyl tensor projected along the normal to the hypersurface and fluid flow, the Weyl scalars and invariant scalars. EBWeyl can also compute the determinant and inverse of a 3x3 or 4x4 matrice in every position of a data box.

astroNN creates neural networks for deep learning using Keras for model and training prototyping while taking advantage of Tensorflow's flexibility. It contains tools for use with APOGEE, Gaia and LAMOST data, though is primarily designed to apply neural nets on APOGEE spectra analysis and predict luminosity from spectra using data from Gaia parallax with reasonable uncertainty from Bayesian Neural Net. astroNN can handle 2D and 2D colored images, and the package contains custom loss functions and layers compatible with Tensorflow or Keras with Tensorflow backend to deal with incomplete labels. The code contains demo for implementing Bayesian Neural Net with Dropout Variational Inference for reasonable uncertainty estimation and other neural nets.

Meanoffset performs astronomical image alignment. The code uses the means of the rows and columns of an original image for alignment and finds the optimal offset corresponding to the maximum similarity by comparing different offsets between images. The similarity is evaluated by the standard deviation of the quotient divided by the means. The code is fast and robust.

EffectiveHalos provides models of the real-space matter power spectrum, based on a combination of the Halo Model and Effective Field Theory, which are 1% accurate up to k = 1 h/Mpc, across a range of cosmologies, including those with massive neutrinos. It can additionally compute accurate halo count covariances (including a model of halo exclusion), both alone and in combination with the matter power spectrum.

BayeSN performs hierarchical Bayesian SED modeling of type Ia supernova light curves. This probabilistic optical-NIR SED model analyzes the population distribution of physical properties as well as cosmology-independent distance estimation for individual SNe. BayeSN is built with NumPyro and Jax (ascl:2111.002) and provides support for GPU acceleration.

Panphasia computes a very large realization of a Gaussian white noise field. The field has a hierarchical structure based on an octree geometry with 50 octree levels fully populated. The code sets up Gaussian initial conditions for cosmological simulations and resimulations of structure formation. Panphasia provides an easy way to publish the linear phases used to set up cosmological simulation initial conditions; publishing phases enriches the literature and makes it easier to reproduce and extend published simulation work.

The superABC sampling method obtains cosmological constraints from supernova light curves using Approximate Bayesian Computation (ABC) without any likelihood assumptions. It provides an interface to two forward model simulations, SNCosmo (ascl:1611.017) and SNANA (ascl:1010.027), for supernova cosmology.

LensIt enables CMB lensing and CMB delensing using the flat-sky approximation. The package can find the maximum posterior estimation of CMB lensing deflection maps from temperature and/or polarization maps and perform Wiener filtering of masked CMB data and allow for inhomogenous noise, including lensing deflections, using a multigrid preconditioner. It contains fast and accurate simulation libraries for lensed CMB skies, and standard quadratic estimator lensing reconstruction tools. LensIt also includes CMB internal delensing tools, including internal delensing biases calculation for temperature and/or polarization maps.

WignerFamilies generates families of Wigner 3j and 6j symbols by recurrence relation. These exact methods are orders of magnitude more efficient than strategies such as prime factorization for problems which require every non-trivial symbol in a family, and are very useful for large quantum numbers. WignerFamilies is thread-safe and very fast, beating the standard Fortran routine DRC3JJ from SLATEC by a factor of 2-4.

PolyBin3D estimates the binned power spectrum and bispectrum for 3D fields such as the distributions of matter and galaxies. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. In the second case, the computation of a Fisher matrix is required; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin3D supports GPU acceleration using JAX. It is a sister code to PolyBin (ascl:2307.020), which computes the polyspectra of data on the two-sphere, and is a modern reimplementation of the former Spectra-Without-Windows (ascl:2108.011) code.

GalMOSS performs two-dimensional fitting of galaxy profiles. This Python-based, Torch-powered tool seamlessly enables GPU parallelization and meets the high computational demands of large-scale galaxy surveys. It incorporates widely used profiles such as the Sérsic, Exponential disk, Ferrer, King, Gaussian, and Moffat profiles, and allows for the easy integration of more complex models. Tested on over 8,000 galaxies from the Sloan Digital Sky Survey (SDSS) g-band with a single NVIDIA A100 GPU, GalMOSS completed classical Sérsic profile fitting in about 10 minutes. Benchmark tests show that GalMOSS achieves computational speeds that are significantly faster than those of default implementations.

TAT-pulsar (Timing Analysis Toolkit for Pulsars) analyzes, processes, and visualizes pulsar data, thus handling the scientific intricacies of pulsar timing. By leveraging observational data from pulsars, along with the associated physical processes and statistical characteristics, the package integrates a suite of Python-based tools and data analysis scripts specifically developed for both isolated pulsars and binary systems. This enables swift analysis and the detailed presentation of timing properties in the high-energy pulsar field. Developed and implemented completely independently from other pulsar timing software such as Stingray (ascl:1608.001) and PINT (ascl:1902.007), TAT-pulsar serves as a valuable cross-checking and supplementary tool for data analysis.

KCWIKit extends the official KCWI DRP (ascl:2301.019) with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.

PIPE (PSF Imagette Photometric Extraction) extracts PSF (point-spread function) photometry from data acquired by the space telescope CHEOPS (CHaracterisation of ExOPlanetS). Advantages of PSF photometry over standard aperture photometry include reduced sensitivity to contaminants such as background stars, cosmic ray hits, and hot/bad pixels. For CHEOPS, an additional advantage is that photometry can be extracted from an imagette, a small window around the target that is downlinked at a shorter cadence than the larger-sized subarray used for aperture photometry. These advantages make PIPE particularly well suited for targets brighter or fainter than the nominal G = 7-11 mag range of CHEOPS, i.e., where short-cadence imagettes are available (bright end) or when contamination becomes a problem (faint end). Within the nominal range, PIPE usually offers no advantage over the standard aperture photometry.

cbeam models the propagation of guided light through slowly-varying few-mode waveguides using the coupled-mode theory (CMT). When compared with more general numerical methods for waveguide simulation, such as the finite-differences beam propagation method (FD-BPM), numerical implementations of the CMT can be much more computationally efficient. Written in Python and Julia, the package provides a Pythonic class structure to define waveguides, with simple classes for directional couplers and photonic lanterns already provided. cbeam also doubles as a finite-element eigenmode solver.

Obsplanning is a suite of tools to help plan astronomical observations from ground-based observatories, for traditional single-site as well as multi-station (VLBI) observing. Conveniently determine observability of objects in the sky from your observatory, and produce plots to help you prepare for your observations over the course of a session. Celestial source coordinates (including solar system objects) can be queried or created, and transformed. Calibrator or reference sources can be selected by proximity, and slew order can be optimized to save valuable telescope time. Plots and visualizations can be easily made to chart source elevation and transits, source proximity to the Sun and Moon, concurrent 'up time' of sources at multiple sites (for VLBI or tandem observations), 'dark time' at a telescope site for a given year, finder plots made from real images (with options to query online databases), and more.

The DensityFieldTools toolset manipulates density fields and measures power spectra and bispectra using a very simple interface. After loading a density field, it computes the power spectrum and the bispectrum for a desired binning. The bispectrum estimator also automatically computes the power spectrum for the chosen binning, to facilitate, for example, shot-noise subtraction. DensityFieldTools also provides a quick way to measure (cross-)power spectra directly from density fields.

CLASS-PT modifies the CLASS (ascl:1106.020) code to compute the non-linear power spectra of dark matter and biased tracers in one-loop cosmological perturbation theory, for both Gaussian and non-Gaussian initial conditions. CLASS-PT can be interfaced with the MCMC sampler MontePython (ascl:1805.027) using the (new and improved) custom-built likelihoods found here.

OneLoopBispectrum computes the one-loop bispectrum of galaxies in redshift space. It computes and simplifies the bispectrum kernels using Mathematica; this is cosmology-independent. The code also computes the full and flattened bispectrum templates, given the pre-computed integration kernels. OneLoopBispectrum uses Mathematica to read in and combine the bispectrum templates, and Python to interpolate and extract the one-loop bispectrum.

URecon reconstructs the initial conditions of N-body simulations from late time (e.g., z=0) density fields. This simple UNET architecture is implemented in TensorFlow and requires Pylians3 (ascl:2403.012) for measuring power spectrum of density fields. The package includes weights trained on Quijote fiducial cosmology simulations.

Pylians3 (Python3 libraries for the analysis of numerical simulations) provides a Python 3 version of Pylians (ascl:1811.008), which analyzes numerical simulations (both N-body and hydrodynamic); parts of the codebase are also written in cython and C. It computes density fields, power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians3 also applies HI+H2 corrections to the output of hydrodynamic simulations, make 21cm maps, computes DLAs column density distribution functions, and can plot density fields and make movies.

LtU-ILI (Learning the Universe Implicit Likelihood Inference) performs machine learning parameter inference. Given labeled training data or a stochastic simulator, the LtU-ILI piepline automatically trains state-of-the-art neural networks to learn the data-parameter relationship and produces robust, well-calibrated posterior inference. The package comes with a wide range of customizable complexity, including posterior-, likelihood-, and ratio-estimation methods for ILI, including sequential learning analogs, and various neural density estimators, including mixture density networks, conditional normalizing flows, and ResNet-like ratio classifiers. It offers fully-customizable, exotic embedding networks, including CNNs and Graph Neural Networks, and a unified interface for multiple ILI backends such as sbi, pydelfi, and lampe. LtU-ILI also handles multiple marginal and multivariate posterior coverage metrics, and offers Jupyter and command-line interfaces and a parallelizable configuration framework for efficient hyperparameter tuning and production runs.

FitCov estimates the covariance of two-point correlation functions in a way that requires fewer mocks than the standard mock-based covariance. Rather than using an analytically fixed correction to some terms that enter the jackknife covariance matrix, the code fits the correction to a mock-based covariance obtained from a small number of mocks. The fitted jackknife covariance remains unbiased, an improvement over other methods, performs well both in terms of precision (unbiased constraints) and accuracy (similar uncertainties), and requires significant less computational power. In addition, FitCov can be easily implemented on top of the standard jackknife covariance computation.