Mosaic is a software package that consists of an interferometric pattern simulator and characterizer, an optimized tiling generator and a beamforming weights calculator. It is being used in the filter-banking beamformer in MeerKAT telescope and more than 200 pulsars have been discovered from the multiple beam observations supported by Mosaic.

Falcon-DM simulates intermediate mass ratio inspirals in DM spikes. This lightweight N-body code is written in C++ and is specifically tuned for simulating IMRIs embedded in dark matter (DM) spikes. It features a 2nd order Drift-Kick-Drift integrator using the symplectic HOLD scheme and symmetrized, individual, time-steps for accurate time-integration. Falcon-DM also offers post-Newtonian (PN) effects up to PN2.5 using the auxiliary velocity algorithm.

Heracles manages harmonic-space statistics on the sphere. It takes catalogs of positions and function values on the sphere and turns them into angular power spectra and mixing matrices. Heracles is both a Python library, to be used in notebooks or data processing pipelines, and a tool for running measurements from the command line using a configuration file.

fastPTA forecasts the sensitivity of future Pulsar Timing Array (PTA) configurations and assesses constraints on Stochastic Gravitational Wave Background (SGWB) parameters. The code can generate mock PTA catalogs with noise levels compatible with current and future PTA experiments. These catalogs can then be used to perform Fisher forecasts of MCMC simulations.

StellarSpectraObservationFitting (SSOF) measures radial velocities and creates data-driven models (with fast, physically-motivated Gaussian Process regularization) for the time-variable spectral features for both the telluric transmission and stellar spectrum measured by Extremely Precise Radial Velocity (EPRV) spectrographs (while accounting for the wavelength-dependent instrumental line-spread function). Written in Julia, SSOF provides two methods for estimating the uncertainties on the RVs and model scores based on the photon uncertainties in the original data. For quick estimates of the uncertainties, the code looks at the local curvature of the likelihood space; the second method for estimating errors is via bootstrap resampling.

Gaspery uses the Fisher Information Matrix (FIM) to evaluate different radial velocity (RV) observing strategies; this assists observational exoplanet astronomers in constructing the observing strategy that maximizes information (or minimizes uncertainty) on the RV semi-amplitude K. The code is flexible and generalizable, however, and can maximize information on any free parameter from any model, given a time series support (x-axis).

Kamodo provides access to, interpolation of, and visualization of space weather models and data. The code allows model developers to represent simulation results as mathematical functions which may be manipulated directly. As the software does not generate model outputs, users must acquire the desired model outputs before these outputs can be functionalized by the software. Kamodo handles unit conversion transparently and supports interactive science discovery through Jupyter notebooks with minimal coding.

CloudCovErr.jl debiases and improves error bar estimates for photometry on top of structured filamentary backgrounds. It first estimates the covariance matrix of the residuals from a previous photometric model and then computes corrections to the estimated flux and flux uncertainties. Using an infilling technique to estimate the background and its uncertainty dramatically improves flux and flux uncertainty estimates for stars in images of fields with significant nebulosity.

ARK implements Computational Fluid Dynamics applications, such as Euler and all-Mach regime, on a Cartesian grid with MPI+Kokkos. It provides a performance-portable Kokkos implementation for compressible hydrodynamics and performs simulations of convection without any approximation of Boussinesq nor anelastic type. It adapts an all-Mach number scheme into a well-balanced scheme for gravity, which preserves arbitrary discrete equilibrium states up to the machine precision. The low-Mach correction in the numerical flux allows ARK to be more precise in the low-Mach regime; the code is well suited for studying highly stratified and high-Mach convective flows.

The 1D radiative-equilibrium model Exo-REM simulates young gas giants far from their star and brown dwarfs. Fluxes are calculated using the two-stream approximation assuming hemispheric closure. The radiative-convective equilibrium is solved assuming that the net flux (radiative + convective) is conservative. The conservation of flux over the pressure grid is solved iteratively using a constrained linear inversion method. Rayleigh scattering from H2, He, and H2O, as well as absorption and scattering by clouds (calculated from extinction coefficient, single scattering albedo, and asymmetry factor interpolated from precomputed tables for a set of wavelengths and particle radii), are also taken into account.

DGEM compares different computation methods for three-dimensional dust continuum radiative transfer. This simple code is based on mcpolar, translated to C++, and refactored to realize and compare radiative transfer techniques, namely Monte Carlo, Quasi-Monte-Carlo, and the Directions Grid Enumeration Method (DGEM). DGEM uses precalculated directions of the photons propagation instead of the random ones to speed up the calculations process. The code also offers a gnuplot script for plotting the resulting images.

1. Configure the basic environment
2. Modify the config file
3. Run auto_task_scheduler.py

lensitbiases is an rFFT-based N1 lensing bias calculation and tests. It is tuned for TT, P-only or MV (GMV) like quadratic estimators. It performs rFFT-based N1 and N1 matrix calculations in ~ O(ms) time per lensing multipole for Planck-like config, which allows on-the-fly evaluation of the bias. It also calculates 5 rFFT's of moderate size per L for N1 TT, 20 for PP, and 45 for MV or GMV. lensitbiases is not particularly efficient for low lensing L's, since in this case one must use large boxes.

DIRTY (DustI Radiative Transfer, Yeah!) computes the radiative transfer and dust emission from arbitrary distributions of dust illuminated by arbitrary distributions of sources (usually stars). It uses Monte Carlo methods to solve the radiative transfer problem in full 3D including non-equilibrium and equilibrium thermal dust emission. As are other similar models, DUSTY is computationally intensive; as a result, it is written in C++.

solar-vSI performs Monte Carlo integration of multi-body phase space efficiently. The calculation of solar antineutrino spectra from 8B decay requires the integration of five-body phase space. Though there is no simple analytical approach to this problem, recursive relations can be used to facilitate numerical evaluations.

measure_extinction measures extinction due to dust absorbing photons or scattering photons out of the line-of-sight. Extinction applies to the case for a star seen behind a foreground screen of dust. This package provides the tools to measure dust extinction curves using observations of two effectively identical stars, differing only in that one is seen through more dust than the other.

Forcepho infers the fluxes and shapes of galaxies from astronomical images. It models the appearance of multiple sources in multiple bands simultaneously and compares to observed data via a likelihood function. Gradients of this likelihood allow for efficient maximization of the posterior probability or sampling of the posterior probability distribution via Hamiltonian Monte Carlo. The model intrinsic galaxy shapes and positions are shared across the different bands, but the fluxes are fit separately for each band. Forcepho does not perform detection; initial locations and (very rough) parameter estimates must be supplied by the user.

BayeSED implements full Bayesian interpretation of spectral energy distributions (SEDs) of galaxies and AGNs. It performs Bayesian parameter estimation using posteriori probability distributions (PDFs) and Bayesian SED model comparison using Bayesian evidence. Its latest version BayeSED3 supports various built-in SED models and can emulate other SED models using machine learning techniques.

iPIC3D performs kinetic plasma simulations at magnetohydrodynamics time scales. This three-dimensional parallel code uses the implicit Particle-in-Cell method; implicit integration in time of the Vlasov–Maxwell system removes the numerical stability constraints. Written in C++, iPIC3D can be run with CUDA acceleration and supports MPI, OpenMP, and multi-node multi-GPU simulations.

vortex-p analyzes the velocity fields of astrophysical simulations of different natures (for example, SPH, moving-mesh, and meshless) usually spanning many orders of magnitude in scales involved. The code performs Helmholtz-Hodge decomposition (HHD); that is, it can decompose the velocity field into a solenoidal and an irrotational/compressive part Helmholtz-Hodge decomposition. vortex-p internally uses an AMR representation of the velocity field and can, in principle, capture the full dynamical range of the simulation. The package can also perform Reynolds decomposition (i.e., the decomposition of the velocity field into a bulk and a turbulent part). This is achieved by means of a multi-scale filtering of the velocity field, where the filtering scale around each point is determined by the local flow properties. vortex-p expands the vortex (ascl:2206.001) code, which had been coupled to the outputs of the MASCLET code, to a fully stand-alone tool capable of working with the outcomes of a broad range of simulation methods.

pysymlog provides utilities for binning, normalizing colors, wrangling tick marks, and other tasks, in symmetric logarithm space. For numbers spanning positive and negative values, the code works in log scale with a transition through zero, down to some threshold. This is useful for representing data that span many scales such as standard log-space that include values of zero or even negative values. pysymlog provides convenient functions for creating 1D and 2D histograms and symmetric log bins, generating logspace-like arrays through zero and managing matplotlib major and minor ticks in symlog space, as well as bringing symmetric log scaling functionality to plotly.

This paper introduces RadioSunPy, an open-source Python package developed for accessing, visualizing, and analyzing multi-band radio observations of the Sun from the RATAN-600 solar complex. The advancement of observational technologies and software for processing and visualizing spectro-polarimetric microwave data obtained with the RATAN-600 radio telescope opens new opportunities for studying the physical characteristics of solar plasma at the levels of the chromosphere and corona. These levels remain some difficult to detect in the ultraviolet and X-ray ranges. The development of these methods allows for more precise investigation of the fine structure and dynamics of the solar atmosphere, thereby deepening our understanding of the processes occurring in these layers. The obtained data also can be utilized for diagnosing solar plasma and forecasting solar activity. However, using RATAN-600 data requires extensive data processing and familiarity with the RATAN-600. The package offers comprehensive data processing functionalities, including direct access to raw data, essential processing steps such as calibration and quiet Sun normalization, and tools for analyzing solar activity. This includes automatic detection of local sources, identifying them with NOAA (National Oceanic and Atmospheric Administration) active regions, and further determining parameters for local sources and active regions. By streamlining data processing workflows, RadioSunPy enables researchers to investigate the fine structure and dynamics of the solar atmosphere more efficiently, contributing to advancements in solar physics and space weather forecasting.

ysoisochrone is a Python3 package that handles the isochrones for young stellar objects (YSOs), and utilize isochrones to derive the stellar mass and ages. Our primary method is a Bayesian inference approach, and the Python code builds on the IDL version developed in Pascucci et al. (2016). The code estimates the stellar masses, ages, and associated uncertainties by comparing their stellar effective temperature, bolometric luminosity, and their uncertainties with different stellar evolutionary models, including those specifically developed for YSOs. User-developed evolutionary tracks can also be utilized when provided in the specific format described in the code documentation.

The kete tools are intended to enable the simulation of all-sky surveys of solar system objects. This includes multi-body physics orbital dynamics, thermal and optical modeling of the objects, as well as field of view and light delay corrections. These tools in conjunction with the Minor Planet Centers (MPC) database of known asteroids can be used to not only plan surveys but can also be used to predict what objects are visible for existing or past surveys.

The primary goal for kete is to enable a set of tools that can operate on the entire MPC catalog at once, without having to do queries on specific objects. It has been used to simulate over 10 years of survey time for the NEO Surveyor mission using 10 million main-belt and near-Earth asteroids.

GalCraft creates mock integral-field spectroscopic (IFS) observations of the Milky Way and other hydrodynamical/N-body simulations. It conducts all the procedures from inputting data and spectral templates to the output of IFS data cubes in FITS format. The produced mock data cubes can be analyzed in the same way as real IFS observations by many methods, particularly codes like Voronoi binning (ascl:1211.006), pPXF (ascl:1210.002), line-strength indices, or a combination of them (e.g., the GIST pipeline, ascl:1907.025). The code is implemented using Python-native parallelization. GalCraft will be particularly useful for directly comparing the Milky Way with other MW-like galaxies in terms of kinematics and stellar population parameters and ultimately linking the Galactic and extragalactic to study galaxy evolution.

pyRRG measures the 2nd and 4th order moments using a TinyTim model to correct for PSF distortions. The code is invariant to the number exposures and orientation of the drizzle images. pyRRG uses a machine learning algorithm to automatically classify stars and galaxies; this can also be done manually if greater accuracy is needed.

Padé simulates protoplanetary disk hydrodynamics in cylindrical coordinates. Written in Fortran90, it is a finite-difference code and the compact 4th-order standard Padé scheme is used for spatial differencing. Padé differentiation is known to have spectral-like resolving power. The z direction can be periodic or non-periodic. The 4th order Runge-Kutta is used for time advancement. Padé implements a version of the FARGO technique to eliminate the time-step restriction imposed by Keplerian advection, and capturing of shocks that are not too strong can be done by using artificial bulk viscosity.

PySR performs Symbolic Regression; it uses machine learning to find an interpretable symbolic expression that optimizes some objective. Over a period of several years, PySR has been engineered from the ground up to be (1) as high-performance as possible, (2) as configurable as possible, and (3) easy to use. PySR is developed alongside the Julia library SymbolicRegression.jl, which forms the powerful search engine of PySR. Symbolic regression works best on low-dimensional datasets, but one can also extend these approaches to higher-dimensional spaces by using "Symbolic Distillation" of Neural Networks. Here, one essentially uses symbolic regression to convert a neural net to an analytic equation. Thus, these tools simultaneously present an explicit and powerful way to interpret deep neural networks.

WISE2MBH uses infrared cataloged data from the Wide-field Infrared Survey Explorer (WISE) to estimate the mass of supermassive black holes (SMBH). It implements a Monte Carlo approach for error propagation, considering mean photometric errors from WISE magnitudes, errors in fits of scaling relations used and scatter of those relations, if available.

PyExoCross, a Python adaptation of ExoCross (ascl:1803.014), post-processes molecular line lists generated by ExoMol, HITRAN, and HITEMP and other similar initiatives. It generates absorption and emission spectra and other properties, including partition functions, specific heats, and cooling functions, based on molecular line lists. The code also calculates cross sections with four line profiles: Doppler, Gaussian, Lorentzian, and Voigt. PyExoCross can convert data format between ExoMol and HITRAN, and supports importing and exporting line lists in the ExoMol and HITRAN/HITEMP formats.

GASTLI (GAS gianT modeL for Interiors) calculates the interior structure models for gas giants exoplanets. The code computes mass-radius curves, thermal evolution curves, and interior composition retrievals to fit a interior structure model to your mass, radius, age, and if available, atmospheric metallicity data. GASTLI can also plot the results, including internal and atmospheric profiles, a pressure-temperature diagram, mass-radius relations, and thermal evolution curves.

symbolic_pofk provides simple Python functions and a Fortran90 routine for precise symbolic emulations of the linear and non-linear matter power spectra and for the conversion σ 8 ↔ A s as a function of cosmology. These can be easily copied, pasted, and modified to other languages. Outside of a tested k range, the fit includes baryons by default; however, this can be switched off.

planetMagFields accesses and analyzes information about magnetic fields of planets in our solar system and visualizes them in both 2D and 3D. The code provides access to properties of a planet, such as dipole tilt, Gauss coefficients, and computed radial magnetic field at surface, and has methods to plot the field and write a vts file for 3D visualization. planetMagFields can be used to produce both 2D and 3D visualizations of a planetary field; it also provides the option of potential extrapolation.

The software framework AMReX is designed for building massively parallel block-structured adaptive mesh refinement (AMR) applications. Key features of AMReX include C++ and Fortran interfaces; 1-, 2- and 3-D support; and support for cell-centered, face-centered, edge-centered, and nodal data. The framework also supports hyperbolic, parabolic, and elliptic solves on hierarchical adaptive grid structure, optional subcycling in time for time-dependent PDEs, and parallelization via flat MPI, OpenMP, hybrid MPI/OpenMP, or MPI/MPI, and parallel I/O. AMReX supports the plotfile format with AmrVis, VisIt (ascl:1103.007), ParaView (ascl:1103.014), and yt (ascl:1011.022).

ClassiPyGRB downloads, processes, visualizes, and classifies GRBs in the Swift/BAT database. Users can query light curves for any GRB and use tools to preprocess the data, including noise/duration reduction and interpolation. The package provides a set of facilities and tutorials for classifying GRBs based on their light curves using a method based on a dimensionality reduction of the data using t-Distributed Stochastic Neighbour Embedding (TSNE); results are visualized using a Graphical User Interface (GUI). ClassiPyGRB also plots and animates the results of the TSNE analysis for a deeper hyperparameter grid search.

BeyonCE (Beyond Common Eclipsers) explores the large parameter space of eclipsing disc systems. The fitting code reduces the parameter space encompassed by the transit of circumsecondary disc (CSD) systems with azimuthally symmetric, non-uniform optical-depth profiles to constrain the size and orientation of discs with a complex sub-structure. BeyonCE does this by rejecting disc geometries that do not reproduce the measured gradients within their light curves.

resonances identifies mean-motion resonances of small bodies. It uses the REBOUND integrator (ascl:1110.016) and automatically identifies two-body and three-body mean-motion resonance in the Solar system. The package can be used for other possible planetary systems, including exoplanets. resonances accurately differentiates different types of resonances (pure, transient, uncertain) and provides an interface for mass tasks, such as finding resonant areas in a planetary system. The software can also plot time series and periodograms.

cloudyfsps is a Python interface between FSPS (ascl:1010.043) and Cloudy (ascl:9910.001). It compiles FSPS models for use as ionizing sources (Stellar SED grids) within Cloudy and generates Cloudy input files, single-parameter or grids of parameters. It runs Cloudy models in parallel and formats the output, which is nebular continuum and nebular line emission, for FSPS input and for explorative manipulation and plotting within Python. cloudyfsps includes pre-packaged plots for BPT diagrams (NII, SII, OI, OII) with observed data from HII regions and SDSS galaxies, and also provides comparisons with MAPPINGS III (ascl:1306.008) models.

Stardust extracts galaxy properties by fitting their multiwavelength data to a set of linearly combined templates. This Python package brings three different families of templates together: 1.) UV+Optical emission from dust unobscured stellar light; 2.) AGN heated dust in the MIR; and 3.) IR dust reprocessed stellar light in the NIR-FIR. Stardust's template fitting does not rely on energy balance. As a result, the total luminosity of dust obscured and dust unobscured stellar light do not rely on each other, and it is possible to fit objects such as SMGs where the energy balance approach might not be applicable.

PICASSO (Python Inpainter for Cosmological and AStrophysical SOurces) provides a suite of inpainting methodologies to reconstruct holes on images (128x128 pixels) extracted from a HEALPIX map. Three inpainting techniques are included; these are divided into two main groups: diffusive-based methods (Nearest-Neighbors), and learning-based methods that rely on training DCNNs to fill the missing pixels with the predictions learned from a training data-set (Deep-Prior and Generative Adversarial Networks). PICASSO also provides scripts for projecting from full sky HEALPIX maps to flat thumbnails images, performing inpainting on GPUs and parallel inpainting on multiple processes, and for projecting from flat images to HEALPIX. Pretrained models are also included.

MCMole3D (Monte-Carlo MOlecular Line Emission) simulates the 3D molecular cloud emission in the Milky Way. In particular, it can simulate both the unpolarized and polarized emission coming from the first rotational line of Carbon Monoxide (CO, J=1-0). MCMole3D seeks to compare the simulated emission with that observed by full sky surveys from the Planck satellite.

FGCluster runs spectral clustering onto Healpix maps for parametric foreground removal, using a map encoding the feature to cluster as inputs. Pixel similarity is given by the geometrical affinity of each pixel in the sphere. FGCluster can also take an uncertainty map as an input, in which case the adjacency is modified in such a way that the pixel similarity accounts also for the statistical significance given by the pixel values in a map and the uncertainties.

SUSHI (Semi-blind Unmixing with Sparsity for hyperspectral images) performs non-stationary unmixing of hyperspectral images. The typical use case is to map the physical parameters such as temperature and redshift from a model with multiple components using data from hyperspectral images. Applying a spatial regularization provides more robust results on voxels with low signal to noise ratio. The code has been used on X-ray astronomy but the method can be applied to any integral field unit (IFU) data cubes.

UltraDark.jl simulates cosmological scalar fields. Written in Julia, it is inspired by PyUltraLight (ascl:1810.009) and designed to be simple to use and extend. It solves a non-interacting scalar field Gross-Pitaevskii equation coupled to Poisson's equation for gravitational potential. The scalar field describes scalar dark matter in models including ultralight dark matter, fuzzy dark matter, axion-like particles and the like. It also describes an inflaton field in the reheating epoch of the early universe.

Written in Python, DarsakX is used to design and analyze the imaging performance of a multi-shell X-ray telescope with an optical configuration similar to Wolter-1 optics for astronomical purposes. It can also assess the impact of figure error on the telescope's imaging performance and optimize the optical design to improve angular resolution for wide-field telescopes. By default, DarsakX uses DarpanX (ascl:2101.015) to calculate the mirror's reflectivity.

SAQQARA analyzes stochastic gravitational wave background signals. This Simulation-based Inference (SBI) library is built on top of the swyft code (ascl:2302.016), which implements neural ratio estimation to efficiently access marginal posteriors for all parameters of interest. Simulation-based inference combined with implicit marginalization (over nuisance parameters) has been shown to be well suited for SGWB data analysis.

21cmFirstCLASS extends 21cmFAST (ascl:1102.023) and interfaces with CLASS (ascl:1106.020) to generate initial conditions at recombination that are consistent with the input cosmological model. These initial conditions can be set during the time of recombination, allowing one to compute the 21cm signal (and its spatial fluctuations) throughout the dark ages, as well as in the proceeding cosmic dawn and reionization epochs, just as in the standard 21cmFAST. 21cmFirstCLASS tracks both the CDM density field δ_c as well as the baryons density field δ_b. In addition, the user interface in 21cmFirstCLASS has been improved and allows one to easily plot the 21cm power spectrum while including noise from the output of 21cmSense (ascl:1609.013).

GRBoondi simulates generalized Proca fields on arbitrary analytic fixed backgrounds; it is based on the publicly available 3+1D numerical relativity code GRChombo (ascl:2306.039). GRBoondi reduces the prerequisite knowledge of numerical relativity and GRChombo in the numerical studies of generalized Proca theories. The main steps to perform a study are inputting the additions to the equations of motion beyond the base Proca theory; GRBoondi can then automatically incorporate the higher-order terms in the simulation. The code is written entirely in C++14 and uses hybrid MPI/OpenMP parallelism. GRBoondi inherits all of the capabilities of the main GRChombo code, which makes use of the Chombo library (ascl:1202.008) for adaptive mesh refinement.

RadioSED uses nested sampling to perform a Bayesian analysis of radio SEDs constructed from radio flux density measurements obtained as part of large area surveys (or in some limited cases, as part of targeted followup campaigns). It is a pure Python implementation, and is essentially a wrapper around Bilby (ascl:1901.011), the Bayesian inference library. RadioSED uses dynesty (ascl:1809.013) to perform the sampling steps, though other samplers could also be used. Users can make use of a pre-defined set of models and surveys from which to draw flux density measurements, or they can define their own models and provide their own input flux density measurements. All flux density measurements are referenced against the RACS-LOW survey, and source names and IDs from the survey catalogue are used as identifiers.

M_SMiLe computes an approximation of the probability of magnification for a lens system consisting of microlensing by compact objects within a galaxy cluster. It specifically focuses on the scenario where the galaxy cluster is strongly lensing a background galaxy and the compact objects, such as stars, are sensitive to this microlensing effect. The microlenses responsible for this effect are stars and stellar remnants, though exotic objects such as compact dark matter candidates (including PBHs and axion mini-halos) can contribute to this effect.