Results 1-100 of 3355 (3271 ASCL, 84 submitted)

[ascl:2311.008]
IQRM: IQRM interference flagging algorithm for radio pulsar and transient searches

IQRM implements the Inter-Quartile Range Mitigation (IQRM) interference flagging algorithm for radio pulsar and transient searches. This module provides only the algorithm that infers a channel mask from some spectral statistic that measures the level of RFI contamination in a time-frequency data block. It should be useful as a reference implementation to developers who wish to integrate IQRM into an existing pipeline or search code.

[ascl:2311.007]
tensiometer: Test a model until it breaks

Tensiometer provides non-Gaussian tension estimators that extend GetDist (ascl:1910.018) capabilities to test the level of agreement or disagreement between different posterior distributions by using kernel density estimates. The code has been used to study the level of internal agreement between different measurements of the clustering of cosmological structures from the Dark Energy Survey and the Planck satellite.

[ascl:2311.006]
MONDPMesh: Particle-mesh code for Milgromian dynamics

MONDPMesh provides a particle-mesh method to calculate the time evolution of an system of point masses under modified gravity, namely the AQUAL formalism. This is done by transforming the Poisson equation for the potential into a system of four linear PDEs, and solving these using fast Fourier transforms. The accelerations on the point masses are calculated from this potential, and the system is propagated using Leapfrog integration. The time complexity of the code is O(N⋅p⋅log(p)) for p pixels and N particles, which is the same as for a Newtonian particle-mesh code.

[ascl:2311.005]
NEOexchange: Target and Observation Manager for the Solar System

Lister, Tim A.; Gomez, Edward; Chatelain, Joseph; Greenstreet, Sarah; Constantinescu, Cora; Phillips, Liz; MacFarlane, Julia; Tedeschi, Adam; Kosic, Isabel

The NEOexchange web portal and Target and Observation Manager ingests solar system objects, including Near-Earth Object (NEO) candidates from the Minor Planet Center, schedules observations on the Las Cumbres Observatory global telescope network and reduces, displays, and analyzes the resulting data. NEOexchange produces calibrated photometry from the imaging data and uses Source Extractor (ascl:1010.064) and SCAMP (ascl:1010.063) to perform object detection and astrometric fitting and calviacat (ascl:2207.015) to perform photometric calibration against photometric catalogs. It also has the ability to perform image registration and subtraction using SWARP (ascl:1010.068) and HOTPANTS (ascl:1504.004) and image stacking, alignment, and faint feature detection using gnuastro (ascl:1801.009).

[ascl:2311.004]
KvW: Modified Kwee–Van Woerden method for eclipse minimum timing with reliable error estimates

The KvW code applies the Kwee Van Woerden (KvW) method for eclipse or transit minimum timing, with an improved error calculation that avoids underestimated errors in minimum times that may appear in the original method. This is particularly the case for low-noise eclipse or transit lightcurves from space or from modern ground instrumentation. The code requires an input light curve of near-equidistant points that contains only the eclipse, without any off-eclipse points, and is available in python and IDL. Both implementaitons return an eclipse minimum time with its error and provide optional text output and plots, as well as several levels of debug information.

[submitted]
atlas-fit

atlas-fit is a python tool to amend the results of [spectroflat] with calibration against a solar atlas. I.e., data for wavelength calibration and continuum-correction is genereted from flat field information and selected solar atlantes

[submitted]
spectroflat

Spectroflat is a generic python calibration library for spectro-polarimetric data. It can be plugged into existing python based data reduction pipelines or used as a standalone calibration and performance ananlzsis tool.

It includes smile distortion correction and flat field extraction.

[submitted]
CRPropa 3.2

Alves Batista, Rafael; Becker Tjus, Julia; Dörner, Julien; Dundovic, Andrej; Eichmann, Björn; Frie, Antonius; Heiter, Christopher; Hoerbe, Mario R.; Kampert, Karl-Heinz; Merten, Lukas; Müller, Gero; Reichherzer, Patrick; Saveliev, Andrey; Schlegel, Leander; Sigl, Günter; van Vliet, Arjen; Winchen, Tobias

The landscape of high- and ultra-high-energy astrophysics has changed in the last decade, largely due to the inflow of data collected by large-scale cosmic-ray, gamma-ray, and neutrino observatories. At the dawn of the multimessenger era, the interpretation of these observations within a consistent framework is important to elucidate the open questions in this field. CRPropa 3.2 is a Monte Carlo code for simulating the propagation of high-energy particles in the Universe. This version represents a major leap forward, significantly expanding the simulation framework and opening up the possibility for many more astrophysical applications. This includes, among others: efficient simulation of high-energy particles in diffusion-dominated domains, self-consistent and fast modelling of electromagnetic cascades with an extended set of channels for photon production, and studies of cosmic-ray diffusion tensors based on updated coherent and turbulent magnetic-field models. Furthermore, several technical updates and improvements are introduced with the new version, such as: enhanced interpolation, targeted emission of sources, and a new propagation algorithm (Boris push). The detailed description of all novel features is accompanied by a discussion and a selected number of example applications.

[ascl:2311.003]
Special-Blurring: Compare quantum-spacetime foam models to GRB localizations

The IDL code Special-Blurring compares models of quantum-foam-induced blurring with the full dataset of gamma-ray burst localizations available from the NASA High Energy Astrophysics Science Research Archive (as of 1 November 2022). This includes GRB221009A, which was especially bright and detected in extremely high energy TeV gamma-rays. An upper limit of the parameter alpha (giving the maximal strength of quantum blurring) can be entered, which is scaled in the model of blurring (called "Phi") operating much like "seeing" from the ground in the optical, and those calculations are plotted against the observations.

[ascl:2311.002]
VCAL-SPHERE: Hybrid pipeline for reduction of VLT/SPHERE data

VCAL-SPHERE, for VIP-based Calibration of VLT/SPHERE data, is a versatile pipeline for high-contrast imaging of exoplanets and circumstellar disks. The pipeline covers all steps of data reduction, including raw calibration, pre-processing and post-processing (*i.e.*, modeling and subtraction of the stellar halo), for the IFS, IRDIS-DBI and IRDIS-CI modes (and combinations thereof) of the VLT instrument SPHERE. The three main steps of the reduction correspond to different modules, where the first follows the recommended EsoRex (ascl:1504.003) workflow and associated recipes with occasional inclusion of VIP (ascl:1603.003) routines (*e.g.*, for PCA-based sky subtraction), while the other two stages fully rely on the VIP toolbox. Although the default parameters of the pipeline should yield a good reduction in most cases, these can be tuned using JSON parameter files for each stage of the pipeline for optimal reduction of specific datasets.

[ascl:2311.001]
wcpy: Wavelength Calibrator

The graphical user interface Wavelength Calibrator facilitates wavelength calibration. Although developed for astronomical data reduction, it can also be used in any place where wavelength calibration is needed.

[submitted]
nemiss: Neutrino emission from hydrocode data

nemiss calculates neutrino emission from an astrophysical jet. nemiss works as part of the PLUTO-nemiss-rlos pipeline. PLUTO (ascl:1010.045) produces a hydrodynamical jet. Then, nemiss calculates beamed neutrino emission at each eligible cell along a given direction in space. Finally, rlos (ascl:1811.009) produces a synthetic neutrino image of the jet along the given direction, taking into consideration the finite nature of the speed of light.

[ascl:2310.012]
GRIZZLY: 1D radiative transfer code

GRIZZLY simulates reionization using a 1D radiative transfer scheme. The code enables the efficient exploration of the parameter space for evaluating 21cm brightness temperature fluctuations near the cosmic dawn. GRIZZLY builds upon the BEARS algorithm for generating simulated reionization maps with density and velocity fields, which are useful for profiling dark matter halos and cosmological density fields.

[ascl:2310.011]
AI-Feynman: Symbolic regression algorithm

AI-Feynman fits analytical expressions to data sets via symbolic regression, mapping the target variable to different features supplied in the data array. Using a neural network with constraints in the number of parameters utilized, the code provides the ability to obtain analytical expressions for normalized features that are used to predict a Pareto-optimal target. AI-Feynman is robust in handling noisy data, recursively generating multidimensional symbolic expressions that match data from an unknown functions.

[ascl:2310.010]
riptide: Pulsar searching with the Fast Folding Algorithm

riptide implements the Fast Folding Algorithm (FFA) to identify periodic signals from time series data. In order to identify faint pulsars, the code provides access to a library of functions and classes for processing dedispersed radio signals. The FFA approaches the theoretical optimum for sensitivity to periodic signals regardless of pulse period and duty cycle.

[ascl:2310.009]
IQRM-APOLLO: Clean narrow-band RFI using Inter-Quartile Range Mitigation (IQRM) algorithm

IQRM-APOLLO cleans narrow-band radio frequency interference (RFI) using the Inter-Quartile Range Mitigation (IQRM) algorithm. By masking this interference, the code reduces the number of false positive pulsar candidates and increases sensitivity for pulsar detection. The IQRM algorithm is an outlier detection algorithm that is both non-parametric and robust to the presences of trends in time series data. Using short-duration data blocks, IQRM-APOLLO computes a spectral statistic that correlates with the presence of RFI, removing high outliers from the input signal.

[ascl:2310.008]
clfd: Clean folded data

Morello, V.; Barr, E. D.; Cooper, S.; Bailes, M.; Bates, S.; Bhat, N. D. R.; Burgay, M.; Burke-Spolaor, S.; Cameron, A. D.; Champion, D. J.; Eatough, R. P.; Flynn, C. M. L.; Jameson, A.; Johnston, S.; Keith, M. J.; Keane, E. F.; Kramer, M.; Levin, L.; Ng, C.; Petroff, E.; Possenti, A.; Stappers, B. W.; van Straten, W.; Tiburzi, C.

clfd (clean folded data) implements GPU-accelerated smart interference removal algorithms to be used on folded pulsar search and pulsar timing data. The code converts each source profile to a small set of representative features, flagging outliers in the resulting feature space. clfd further visualizes the outlier flagging process, as well as the resulting two-dimensional time-frequency mask that is applied to the clean archive. The code provides access to cleaning algorithms that were initially developed for the High Time Resolution Universe (HTRU) survey which found several pulsars.

[ascl:2310.007]
zCluster: Measure photometric redshifts for galaxy clusters

zCluster measures galaxy cluster photometric redshifts using data from broadband photometry in large public surveys, given a priori knowledge of the cluster position. The code retrieves and uses redshift probability distributions in order to create a projected two-dimensional density map of a targeted galaxy cluster, which is later convolved with a Gaussian kernel to smooth the map. zCluster also produces photometric redshift estimates and galaxy density maps for any point in the sky using the included zField tool.

[ascl:2310.006]
MAGPy-RV: Gaussian Process regression pipeline with MCMC parameter searching

MAGPy-RV (Modelling stellar Activity with Gaussian Processes in Radial Velocity) models data with Gaussian Process regression and affine invariant Monte Carlo Markov Chain parameter searching. Developed to model intrinsic, quasi-periodic variations induced by the host star in radial velocity (RV) surveys for the detection of exoplanets and the accurate measurements of their orbital parameters and masses, it now includes a variety of kernels and models and can be applied to any timeseries analysis. MAGPy-RV includes publication level plotting, efficient posterior extraction, and export-ready LaTeX results tables. It also handles multiple datasets at once and can model offsets and systematics from multiple instruments. MAGPy-RV requires no external dependencies besides basic python libraries and corner (ascl:1702.002).

[ascl:2310.005]
DustPyLib: A library of DustPy extensions

The DustPyLib library contains auxiliary modules for the dust evolution software DustPy (ascl:2207.016), which simulates the evolution of dust and gas in protoplanetary disks. DustPyLib includes interfaces to radiative transfer codes and modules with extensions to the DustPy defaults.

[ascl:2310.004]
q3dfit: PSF decomposition and spectral analysis for JWST-IFU spectroscopy

Rupke, David; Wylezalek, Dominika; Zakamska, Nadia; Veilleux, Sylvain; Vayner, Andrey; Bertemes, Caroline; Ishikawa, Yuzo; Liu, Weizhe; Lim, Hui Xian Grace; Murphree, Grey; Whitesell, Lillian; McCrory, Ryan; Anicetti, Carlos

q3dfit performs PSF decomposition and spectral analysis for high dynamic range JWST IFU observations, allowing the user to create science-ready maps of relevant spectral features. The software takes advantage of the spectral differences between quasars and their host galaxies for maximal-contrast subtraction of the quasar point-spread function (PSF) to reveal and characterize the faint extended emission of the host galaxy. Host galaxy emission is carefully fit with a combination of stellar continuum, emission and absorption of dust and ices, and ionic and molecular emission lines.

[ascl:2310.003]
wwz: Weighted wavelet z-transform code

wwz provides a python3 implementation of the Foster weighted wavelet z-transform, a wavelet-based method for periodicity analysis of unevenly sampled data.

[ascl:2310.002]
lcsim: Light curve simulation code

lcsim creates artificial light curves using two algorithms. The first simulates Gaussian distributed light curves following a specific power spectral density (PSD) freely selectable by the user. The second algorithm simulates light curves following a specific PSD and matching a specific probability density function (PDF). The package provides methods to resample the simulated light curves and add "observational" noise. Furthermore, the package provides an interface to a SQLite3-based database to store and access the simulations.

[ascl:2310.001]
celerite2: Fast and scalable Gaussian Processes in one dimension

celerite2 is a re-write of celerite (ascl:1709.008), an algorithm for fast and scalable Gaussian Process (GP) Regression in one dimension. celerite2 improves numerical stability and integration with various machine learning frameworks. The implementation includes interfaces in Python and C++, with full support for PyMC (ascl:1610.016) and JAX (ascl:2111.002).

[ascl:2309.020]
PlanetSlicer: Orange-slice algorithm for fitting brightness maps to phase curves

PlanetSlicer fits brightness maps to phase curves using the "orange-slice" method and works both for self-luminous objects and those that diffuse reflected light assuming Lambertian reflectance. In both cases, the model supposes that a spherical object can be divided into slices of constant brightness (or albedo) which may be integrated to yield the total flux observed, given the angles of observation. The package contains two key functions: toPhaseCurve and fromPhaseCurve; the former integrates the brightness for each slice to calculate the observed total flux from the object, given the longitude of observation. The latter does the opposite, estimating the brightness of the slices from a set of observed total flux (the phase curve).

[ascl:2309.019]
FRISBHEE: FRIedmann Solver for Black Hole Evaporation in the Early-universe

FRISBHEE (FRIedmann Solver for Black Hole Evaporation in the Early-universe solves the Friedmann - Boltzmann equations for Primordial Black Holes + SM radiation + BSM Models. Considering the collapse of density fluctuations as the PBH formation mechanism, the code handles monochromatic and extended mass and spin distributions. FRISBHEE can return the full evolution of the PBH, SM and Dark Radiation comoving energy densities, together with the evolution of the PBH mass and spin as a function of the log_{10} at scale factor, and can determine the relic abundance in the case of Dark Matter produced from BH evaporation for monochromatic and extended distributions.

[ascl:2309.018]
Sprout: Moving mesh finite volume hydro code

The finite volume hydro code Sprout uses a simple expanding Cartesian grid to track outflows for several orders of magnitudes in expansion. It captures shocks whether they are aligned or misaligned with the grid, and provides second-order convergence for smooth flows. The code's expanding mesh capability reduces numerical diffusion drastically for outflows, especially when the analytic nature of the bulk flow is known beforehand. Sprout can be used to study fluid instabilities in expanding flows, such as in SN explosions and jets; it resolves fine fluid structures at small length scales and expand the mesh gradually as the structures grow.

[ascl:2309.017]
ChEAP: Chemical Evolution Analytic Package

ChEAP (Chemical Evolution Analytic Package) implements an analytic solution for the chemical evolution model of the Galaxy that extends the instantaneous recycling approximation with the contribution of Type Ia SNe. The code works for different prescriptions of the delay time distributions (DTDs), including the single and double degenerate scenarios, and allows the inclusion of an arbitrary number of pristine gas infalls. The required functions are contained in the CheapTools.py file, which is imported as a Python library. ChEAP also includes code to illustrate, with a random-parameter chemical evolution model, the accuracy of this analytic solution compared to one using numerical integration.

[ascl:2309.016]
PEREGRINE: Gravitational wave parameter inference with neural ration estimation

PEREGRINE performs full parameter estimation on gravitational wave signals. Using an internal Truncated Marginal Neural Ratio Estimation (TMNRE) algorithm and building upon the swyft (ascl:2302.016) code to efficiently access marginal posteriors, PEREGRINE conducts a sequential simulation-based inference approach to support the analysis of both transient and continuous gravitational wave sources. The code can fully reconstruct the posterior distributions for all parameters of spinning, precessing compact binary mergers using waveform approximants.

[ascl:2309.015]
bskit: Bispectra from cosmological simulation snapshots

bskit, built upon the nbodykit (ascl:1904.027) simulation analysis package, measures density bispectra from snapshots of cosmological N-body or hydrodynamical simulations. It can measure auto or cross bispectra in a user-specified set of triangle bins (that is, triplets of 3-vector wavenumbers). Several common sets of bins are also implemented, including all triangle bins for specified k_min and k_max, equilateral triangles between specified k_min and k_max, isosceles triangles, and squeezed isosceles triangles.

[ascl:2309.014]
fitScalingRelation: Fit galaxy cluster scaling relations using MCMC

fitScalingRelation fits galaxy cluster scaling relations using orthogonal or bisector regression and MCMC. It takes into account errors on both variables and intrinsic scatter. Although it geared for fitting galaxy cluster scaling relations of all kinds, it can be used for any kind of regression problem with errors on both variables and intrinsic scatter.

[ascl:2309.013]
maszcal: Mass calibrations for thermal-SZ clusters

maszcal calibrates the observable-mass relation for galaxy clusters, with a focus on the thermal Sunyaev-Zeldovich signal's relation to mass. maszcal explicitly models baryonic matter density profiles, differing from most previous approaches that treat galaxy clusters as purely dark matter. To do this, it uses a generalized Nararro-Frenk-White (GNFW) density to represent the baryons, while using the more typical NFW profile to represent dark matter.

[ascl:2309.012]
StarbugII: JWST PSF photometry for crowded fields

The python photometry suite StarbugII provides accurate photometry on point-like sources embedded in complex diffuse emissions. The tool has a simple modular interface with a wide range of photometric routines including embedded source detection, aperture and PSF photometry, diffuse background emission estimation, catalog matching and artificial star testing. The core is built around Photutils (ascl:1609.011).

[ascl:2309.011]
PCOSTPD: Periodogram Comparison for Optimizing Small Transiting Planet Detection

The Periodogram Comparison for Optimizing Small Transiting Planet Detection R code compares two periodogram algorithms for detecting transiting exoplanets: the Box-fitting Least Squares (BLS) and the Transit Comb Filter (TCF). It calculates the False Alarm Probability (FAP) based on extreme value theory and signal-to-noise ratio (SNR) metrics to quantify periodogram peak significance. The comparison approach is aimed at optimizing the detection of small transiting planets in future transiting exoplanet surveys. The code can be extended for comparing any set of periodograms.

[ascl:2309.010]
pymccorrelation: Correlation coefficients with uncertainties

pymccorrelation calculates correlation coefficients for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient and p-value. The code supports Pearson's r, Spearman's rho, and Kendall's tau. Calculations of Kendall's tau additionally support censored data. This code supercedes and expands the deprecated code pymcspearman (ascl:2309.009).

[ascl:2309.009]
pymcspearman: Monte carlo calculation of Spearman's rank correlation coefficient with uncertainties

pymcspearman is a python implementation of MCSpearman (ascl:1504.008) and calculates Spearman's rank correlation coefficient for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient. This software project has migrated (and expanded) to pymccorrelation (ascl:2309.010).

[submitted]
tomso: TOols for Models of Stars and their Oscillations

Many branches of astronomy interpret observations through approximate, one-dimensional models of stars. Furthermore, many stars are observed to undergo resonant pulsations, and the frequencies at which they do so are similarly interpreted through the predicted pulsations of the one-dimensional models. The study of these resonant pulsations in stars is known as asteroseismology. Since the equations of stellar structure, evolution and pulsation were defined in their modern forms around the mid-20th century, many programs have been written to produce models and predict their pulsations frequencies and correspondingly many custom data formats have been defined, with varying levels of ease-of-use and interoperability. tomso's main purpose is to provide a compact interface for parsing data in these formats and simplify research that uses them.

[submitted]
PIPPIN: Polarimetric Differential Imaging (PDI) pipeline for NACO data

PIPPIN (PDI pipeline for NACO data) is a pipeline developed to reduce the polarimetric observations made with the VLT/NACO instrument. It applies the Polarimetric Differential Imaging (PDI) technique to distinguish the polarised, scattered light from the (largely) un-polarised, stellar light. As a result, circumstellar dust can be uncovered. During its operation, NACO employed different instrument configurations (e.g. half-wave plate or de-rotator usage, Wollaston beam-splitter or wiregrid observations) which are appropriately handled by PIPPIN. As part of the PDI reduction, PIPPIN performs various levels of corrections for instrumental polarisation and crosstalk.

[submitted]
INSPECTA: INtegrated SDHDF Processing Engine in C for Telescope data Analysis

INSPECTA (formerly sdhdfProc) is a software package to read, manipulate and process radio astronomy data in Spectral-Domain Hierarchical Data Format (SDHDF). It is available as part of the 'sdhdf_tools' repository.

[submitted]
A pseudo GUI with pyplot

Working with a GUI, or adding interaction in plotting, will help a lot in data analysis. However, the common GUI of Python is OS-dependent, while manually adding interactive codes is too complex. A pseudo-GUI tool is introduced in this work. It will help to add buttons/checkers in the graph and assign callback functions to them. The remaining problem is that the documents in this package are in Chinese and will be in English in the next version. This program is published to the PyPI, and can be installed by 'pip install pltgui'.

[submitted]
qmatch: Some astronomical image matching programs

Matching stars in astronomical images is an essential step in data reduction. This work includes some matching programs implemented by Python: simple matching, fast matching, and triangle matching. For two catalogs with m and n objects, the simple method has a time and space complexity of O(m*n) but is fast for fewer n or m. The time complexity of the fast method is O(mlogm+nlogn). The triangle method will work between rotated and scaled images. All methods are applied in pipelines and work well. This package is published to the PyPI with the name 'qmatch'.

[submitted]
LOFAR H5plot

Calibration solutions for the LOFAR radio telescope are stored in a 5-dimensional (time, frequency, station, polarisation and direction in the sky) HDF5 table. H5plot is a GUI application focussing on interactive visual inspection of these calibration solutions.

[ascl:2309.008]
PI: Plages Identification

Plages Identification identifies solar plages from Ca II K photographic observations irrespective of noise level, brightness, and other image properties. The code provides an efficient, reliable method for identifying solar plages. The output of the algorithm is an image highlighting the plages and the calculated plage index. Plages Identification is also deployed as a webapp, allowing users to experiment with different hyperparameters and visualize their impact on the output image in real time.

[ascl:2309.007]
MATRIX: Multi-phAse Transits Recovery from Injected eXoplanets toolkit

The injection-recovery MATRIX (Multi-phAse Transits Recovery from Injected eXoplanets) Toolkit creates grids of scenarios with a set of periods, radii, and epochs of synthetic transiting exoplanet signals in a provided light curve. Typical injection-recovery executions consist of 2-dimensional scenarios, where only one epoch (random or hardcoded) was used for each period and radius, which may reduce accuracy. MATRIX performs multi-phase analyses needing only a few parameters in a configuration file and running one line of code.

[ascl:2309.006]
CoLFI: Cosmological Likelihood-Free Inference

CoLFI (Cosmological Likelihood-Free Inference) estimates parameters directly from the observational data sets using neural density estimators (NDEs); it is a fully ANN-based framework that differs from the Bayesian inference. The package contains three NDEs that are used to estimate parameters: an artificial neural network (ANN), a mixture density network (MDN), and a mixture neural network (MNN). CoLFI can learn the conditional probability density using samples generated by models, and the posterior distribution can be obtained for given observational data.

[ascl:2309.005]
DeepGlow: Neural network emulator for BOXFIT

The feed-forward neural network DeepGlow emulates BOXFIT (ascl:2306.059) simulation data of gamma-ray burst (GRB) afterglows. The package provides an easy interface to generate GRB afterglow spectra and light curves mimicking those generated through BOXFIT with high accuracy. The code used to generate the training data and to train the neural networks is also included.

[ascl:2309.004]
GWSim: Mock gravitational waves event generator

GWSim generates mock gravitational waves (GW) events corresponding to different binary black holes (BBHs) population models. It can incorporate scenarios of GW mass models, GW spin distributions, the merger rate, and the cosmological parameters. GWSim generates samples of binary compact objects for a fixed amount of observation time, duty cycle, and configurations of the detector network; the universe created by the code is uniform in comobile volume.

[ascl:2309.003]
Swiftbat: Utilities for handing BAT instrument data from the Neil Gehrels Swift Observatory

Swiftbat retrieves, analyzes, and displays data from NASA's Swift spacecraft, especially data from the Swift Burst Alert Telescope (BAT). All BAT data are available from the Swift data archive; however, a few routines in this library use data access methods not available to the general public and thus are useful only to Swift team members. The package also installs a command-line program 'swinfo' that provides Swift Information such as what the MET (onboard-clock) time is, where Swift was pointing, and whether a specific source was above the horizon and/or in the field of view.

[ascl:2309.002]
UBHM: Uncertainty quantification of black hole mass estimation

Uncertain_blackholemass predicts virial black hole masses using a neural network model and quantifies their uncertainties. The scripts retrieve data and run feature extraction and uncertainty quantification for regression. They can be used separately or deployed to existing machine learning methods to generate prediction intervals for the black hole mass predictions.

[ascl:2309.001]
TRES: TRiple Evolution Simulation package

TRES simulates hierarchical triple systems with stellar and planetary components, including stellar evolution, stellar winds, tides, general relativistic effects, mass transfer, and three-body dynamics. It combines stellar evolution and interactions with three-body dynamics in a self-consistent way. The code includes the effects of common-envelope evolution, circularized stable mass transfer, tides, gravitational wave emission and up-to-date stellar evolution through SeBa (ascl:1201.003). Other stellar evolution codes, such as SSE (ascl:1303.015), can also be used. TRES is written in the AMUSE (ascl:1107.007) software framework.

[ascl:2308.015]
FishLSS: Fisher forecasting for Large Scale Structure surveys

FishLSS computes the Fisher information matrix for a set of observables and model parameters. It can model the redshift-space power spectrum of any biased tracer of the CDM+baryon field and the post-reconstruction galaxy power spectrum. The code also models the projected cross-correlation of galaxies with the CMB lensing convergence, the projected galaxy power spectrum, and the CMB lensing convergence power spectrum. FishLSS requires pyFFTW (ascl:2109.009), velocileptors (ascl:2308.014), and CLASS (ascl:1106.020).

[ascl:2308.014]
velocileptors: Velocity-based Lagrangian and Eulerian PT expansions of redshift-space distortions

velocileptors computes the real- and redshift-space power spectra and correlation functions of biased tracers using 1-loop perturbation theory (with effective field theory counter terms and up to cubic biasing) as well as the real-space pairwise velocity moments. It provides simple computation of the power spectrum wedges or multipoles, and uses a reduced set of parameters for computing the most common case of the redshift-space power spectrum. In addition, velocileptors offers two "direct expansion" modules available in LPT and EPT.

[ascl:2308.013]
Driftscan: Drift scan telescope analysis

Driftscan simulates and analyzes transit radio interferometers, with a particular focus on 21cm cosmology. Given a design of a telescope, it generates a set of products used to analyze data from it and simulate timestreams. Driftscan also constructs a filter to extract cosmological 21 cm emission from astrophysical foregrounds, such as our galaxy and radio point sources, and estimates the 21cm power spectrum using an optimal quadratic estimator.

[ascl:2308.012]
KeplerFit: Keplerian velocity distribution model fitter

Bosco, Felix; Beuther, H.; Ahmadi, A.; Mottram, J. C; Kuiper, R.; Linz, H.; Maud, L.; Winters, J. M.; Henning, T.; Feng, S.; Peters, T.; Semenov, D.; Klaassen, P. D.; Schilke, P.; Urquhart, J. S.; Beltrán, M. T.; Lumsden, S. L.; Leurini, S.; Moscadelli, L.; Cesaroni, R.; Sánchez-Monge, Á.; Palau, A.; Pudritz, R.; Wyrowski, F.; Longmore, S.

KeplerFit fits a Keplerian velocity distribution model to position-velocity (PV) data to obtain an estimate of the enclosed mass. The code extracts the scales of the pixels in both directions, spatial and spectral, then extracts the most extreme velocity at each position; this returns two arrays of positions and velocities. KeplerFit then models the extracted PV data and returns a set of the best-fit parameters, the standard deviations in each of the parameters, and the total residual of the fit.

[ascl:2308.011]
glmnet: Lasso and elastic-net regularized generalized linear models

Friedman, Jerome; Hastie, Trevor; Tibshirani, Rob; Narasimhan, Balasubramanian; Tay, Kenneth; Simon, Noah; Qian, Junyang; Yang, James

glmnet efficiently fits the entire lasso or elastic-net regularization path for linear regression (gaussian), multi-task gaussian, logistic and multinomial regression models (grouped or not), Poisson regression and the Cox model. The algorithm uses cyclical coordinate descent in a path-wise fashion.

[ascl:2308.010]
BCemu: Model baryonic effects in cosmological simulations

BCMemu provides emulators to model the suppression in the power spectrum due to baryonic feedback processes. These emulators are based on the baryonification model, where gravity-only N-body simulation results are manipulated to include the impact of baryonic feedback processes. The package also has a three parameter barynification model; the first assumes all the three parameters to be independent of redshift while the second assumes the parameters to be redshift dependent.

[ascl:2308.009]
caput: Utilities for building radio astronomy data analysis pipelines

Shaw, J. Richard; Masui, Kiyoshi; Nitsche, Rick; Boskovic, Anja; Zuo, Shifan; Gray, Liam; Fandino, Mateus; Wiebe, Donald V.; Siegel, Seth R.

Caput (Cluster Astronomical Python Utilities) contains utilities for handling large datasets on computer clusters. Written with radio astronomy in mind, the package provides an infrastructure for building, managing and configuring pipelines for data processing. It includes modules for dynamically importing and utilizing mpi4py, in-memory mock-ups of h5py objects, and infrastructure for running data analysis pipelines on computer clusters. Caput features a generic container for holding self-documenting datasets in memory with straightforward syncing to h5py files, and offers specialization for holding time stream data. Caput also includes tools for MPI-parallel analysis and routines for converting between different time representations, dealing with leap seconds, and calculating celestial times.

[ascl:2308.008]
Rapster: Rapid population synthesis for binary black hole mergers in dynamical environments

Rapster (RAPid cluSTER evolution) models binary black hole population synthesis and the evolution of star clusters based on simple, yet realistic prescriptions. The code can generate large populations of dynamically formed binary black holes. Rapster uses SEVN (ascl:2206.019) to model the initial black hole mass spectrum and PRECESSION (ascl:1611.004) to model the mass, spin, and gravitational recoil of merger remnants.

[ascl:2308.007]
DiskMINT: Disk Model For INdividual Targets

DiskMINT (Disk Model for INdividual Targets) models individual disks and derives robust disk mass estimates. Built on RADMC-3D (ascl:1202.015) for continuum (and gas line) radiative transfer, the code includes a reduced chemical network to determine the C18O emission. DiskMINT has a Python3 module that generates a self-consistent 2D disk structure to satisfy VHSE (Vertical Hydrostatic Equilibrium). It also contains a Fortran code of the reduced chemical network that contains the main chemical processes necessary for C18O modeling: the isotopologue-selective photodissociation, and the grain-surface chemistry where the CO converting to CO2 ice is the main reaction.

[ascl:2308.006]
Nemo: Millimeter-wave map filtering and Sunyaev-Zel'dovich galaxy cluster and source detection

Hilton, Matt; Aiola, Simone; Alonso, David; Hasselfield, Matthew; Huffenberger, Kevin; Marriage, Toby; MacCrann, Niall; Naess, Sigurd; Sifón, Cristóbal

Nemo detects millimeter-wave Sunyaev-Zel'dovich galaxy clusters and compact sources. Originally developed for the Atacama Cosmology Telescope project, the code is capable of analyzing the next generation of deep, wide multifrequency millimeter-wave maps that will be produced by experiments such as the Simons Observatory. Nemo provides several modules for analyzing ACT/SO data in addition to the command-line programs provided in the package.

[ascl:2308.005]
FastSpecFit: Fast spectral synthesis and emission-line fitting of DESI spectra

FastSpecFit models the observed-frame optical spectroscopy and broadband photometry of extragalactic targets using physically grounded stellar continuum and emission-line templates. The code handles data from the Dark Energy Spectroscopic Instrument (DESI) Survey, which is amassing spectrophotometry for an unprecedented 40 million extragalactic targets, although the algorithms are general enough to accommodate other upcoming, massively multiplexed spectroscopic surveys. FastSpecFit extracts nearly 800 observed- and rest-frame quantities from each target, including light-weighted ages and stellar velocity dispersions based on the underlying stellar continuum; line-widths, velocity shifts, integrated fluxes, and equivalent widths for nearly 40 rest-frame ultraviolet, optical, and near-infrared emission lines arising from both star formation and active galactic nuclear activity; and K-corrections and rest-frame absolute magnitudes and colors. Moreover, FastSpecFit is designed with speed and parallelism in mind, enabling it to deliver robust model fits to tens of millions of targets.

[ascl:2308.004]
AstroPhot: Fitting everything everywhere all at once in astronomical images

Stone, Connor; Courteau, Stéphane; Cuillandre, Jean-Charles; Hezaveh, Yashar; Perreault-Levasseur Laurence; Arora Nikhil

AstroPhot quickly extracts detailed information from complex astronomical data for individual images or large survey programs. It fits models for sky, stars, galaxies, PSFs, and more in a principled chi^2 forward optimization, recovering Bayesian posterior information and covariance of all parameters. The code optimizes forward models on CPU or GPU, across images that are large, multi-band, multi-epoch, rotated, dithered, and more. Models are optimized together, thus handling overlapping objects and including the covariance between parameters (including PSF and galaxy parameters). AstroPhot includes several optimization algorithms, including Levenberg-Marquardt, Gradient descent, and No-U-Turn MCMC sampling.

[ascl:2308.003]
SIMBI: 3D relativistic gas dynamics code

SIMBI simulates heterogeneous relativistic gas dynamics up to 3d for special relativistic hydrodynamics and up to 2D Newtonian hydrodynamics. It supports user-defined mesh expansion and contraction, density, momentum, and energy density terms outside of grid; the code also supports source terms in the Euler equations and source terms at the boundaries. Boundary conditions, which include periodic, reflecting, outflow, and inflow boundaries, are given as an array of strings. If an inflow boundary condition is set but no inflow boundary source terms are given, SIMBI switches to outflow boundary conditions to prevent crashes. The code can track a single passive scalar, insert an immersed boundary, and is impermeable by default. SIMBI USES the Cython framework to blend together C++, CUDA, HIP, and Python.

[ascl:2308.002]
FLATW'RM: Finding flares in Kepler data using machine-learning tools

FLATW'RM (FLAre deTection With Ransac Method) detects stellar flares in light curves using a classical machine-learning method. The code tries to find a rotation period in the light curve and splits the data to detection windows. The light curve sections are fit with the robust fitting algorithm RANSAC (Random sample consensus); outlier points (flare candidates) above the pre-set detection level are marked for each section. For the given detection window, only those flare candidates that have at least a given number of consecutive points (three by default) are kept and marked as flares. When using FLATW’RM, the code's output should be checked to determine whether changes to the default settings are needed to account for light curve noise, data sampling frequency, and scientific needs.

[ascl:2308.001]
MOOG_SCAT: Scattering version of the MOOG Line Transfer Code

MOOG_SCAT, a redevelopment of the LTE radiative transfer code MOOG (ascl:1202.009), contains modifications that allow for the treatment of isotropic, coherent scattering in stars. MOOG_SCAT employs a modified form of the source function and solves radiative transfer with a short charactersitics approach and an acclerated lambda iteration scheme.

[ascl:2307.062]
FABADA: Non-parametric noise reduction using Bayesian inference

FABADA (Fully Adaptive Bayesian Algorithm for Data Analysis) performs non-parametric noise reduction using Bayesian inference. It iteratively evaluates possible smoothed models of the data to estimate the underlying signal that is statistically compatible with the noisy measurements. Iterations stop based on the evidence *E* and the χ^{2} statistic of the last smooth model, and the expected value of the signal is computed as a weighted average of the smooth models. Though FABADA was written for astronomical data, such as spectra (1D) or images (2D), it can be used as a general noise reduction algorithm for any one- or two-dimensional data; the only requisite of the input data is an estimation of its associated variance.

[ascl:2307.061]
connect: COsmological Neural Network Emulator of CLASS using TensorFlow

connect (COsmological Neural Network Emulator of CLASS using TensorFlow) emulates cosmological parameters using neural networks. This includes both sampling of training data and training of the actual networks using the TensorFlow library. connect aids in cosmological parameter inference by immensely speeding up the process, which is achieved by substituting the cosmological Einstein-Boltzmann solver codes, needed for every evaluation of the likelihood, with a neural network with a 10^{2} to 10^{3} times faster evaluation time. The code requires CLASS (ascl:1106.020) and Monte Python (ascl:1307.002) if iterative sampling is used.

[ascl:2307.060]
MBASC: Multi-Band AGN-SFG Classifier

Karsten, J.; Wang, L.; Margalef-Bentabol, B.; Best, P. N.; Kondapally, R.; La Marca, A.; Morganti, R.; Röttgering, H. J. A.; Vaccari, M.; Sabater, J.

MBASC (Multi-Band AGN-SFG Classifier) classifies sources as Active Galactic Nuclei (AGNs) and Star Forming Galaxies (SFGs). The algorithm is based on the light gradient-boosting machine ML technique. MBASC can use a wide range of multi-wavelength data and redshifts to predict a classification for sources.

[ascl:2307.059]
orbitN: Symplectic integrator for near-Keplerian planetary systems

orbitN generates accurate and reproducible long-term orbital solutions for near-Keplerian planetary systems with a dominant mass M0. The code focuses on hierarchical systems without close encounters but can be extended to include additional features. Among other features, the package includes M0's quadrupole moment, a lunar contribution, and post-Newtonian corrections (1PN) due to M0 (fast symplectic implementation). To reduce numerical roundoff errors, orbitN features Kahan compensated summation.

[ascl:2307.058]
APOLLO: Radiative transfer and atmosphere spectroscopic retrieval for exoplanets

APOLLO forward models the radiative transfer of light through a planetary (or brown dwarf) atmosphere; it also forward models transit and emission spectra and retrieves atmospheric properties of extrasolar planets. The code has two operational modes: one to compute a planetary spectrum given a set of parameters, and one to retrieve those parameters based on an observed spectrum. The package uses emcee (ascl:1303.002) to find the best fit to a spectrum for a given parameter set. APOLLO is modular and offers many options that may be turned on and off, including the type of observations, a flexible molecular composition, multiple cloud prescriptions, multiple temperature-pressure profile prescriptions, multiple priors, and continuum normalization.

[ascl:2307.057]
species: Atmospheric characterization of directly imaged exoplanets

species (**spe**ctral **c**haracterization and **i**nference for **e**xoplanet **s**cience) provides a coherent framework for spectral and photometric analysis of directly imaged exoplanets and brown dwarfs which builds on publicly-available data and models from various resources. species contains tools for grid and free retrievals using Bayesian inference, synthetic photometry, interpolating a variety atmospheric and evolutionary model grids (including the possibility to add a custom grid), color-magnitude and color-color diagrams, empirical spectral analysis, spectral and photometric calibration, and analysis of emission lines.

[ascl:2307.056]
HELA: Random Forest retrieval for exoplanet atmospheres

HELA performs atmospheric retrieval on exoplanet atmospheres using a Random Forest algorithm. The code has two stages: training (which includes testing), and predicting. It requires a training set that matches the format of the data to be analyzed, with the same number of points and a sample spectrum for each parameter. The number of trees used and the number of jobs are editable. The HELA package includes a training set and data as examples.

[ascl:2307.055]
plan-net: Bayesian neural networks for exoplanetary atmospheric retrieval

Cobb, Adam D.; Himes, Michael D.; Soboczenski, Frank; Zorzan, Simone; O'Beirne, Molly D.; Güneş Baydin, Atılım; Gal, Yarin; Domagal-Goldman, Shawn D.; Arney, Giada N.; Angerhausen, Daniel

plan-net uses machine learning with an ensemble of Bayesian neural networks for atmospheric retrieval; this approach yields greater accuracy and more robust uncertainties than a single model. A new loss function for BNNs learns correlations between the model outputs. Performance is improved by incorporating domain-specific knowledge into the machine learning models and provides additional insight by inferring the covariance of the retrieved atmospheric parameters.

[ascl:2307.054]
LEFTfield: Forward modeling of cosmological density fields

LEFTfield forward models cosmological matter density fields and biased tracers of large-scale structure. The model, written in C++ code, is centered around classes encapsulating scalar, vector, and tensor grids. It includes the complete bias expansion at any order in perturbations and captures general expansion histories without relying on the EdS approximation; however, the latter is also implemented and results in substantially smaller computational demands. LEFTfield includes a subset of the nonlinear higher-derivative terms in the bias expansion of general tracers.

[submitted]
backtrack: fit relative motion of candidate direct imaging sources with background proper motion and parallax

Directly imaged planet candidates (high contrast point sources near bright stars) are often validated, among other supporting lines of evidence, by comparing their observed motion against the projected motion of a background source due to the proper motion of the bright star and the parallax motion due to the Earth's orbit. Often, the "background track" is constructed assuming an interloping point source is at infinity and has no proper motion itself, but this assumption can fail, producing false positive results, for crowded fields or insufficient observing time-baselines (e.g. Nielsen et al. 2017). `backtrack` is a tool for constructing background proper motion and parallax tracks for validation of high contrast candidates. It can produce classical infinite distance, stationary background tracks, but was constructed in order to fit finite distance, non-stationary tracks using nested sampling (and can be used on clusters). The code sets priors on parallax based on the relations in Bailer-Jones et al. 2021 that are fit to Gaia eDR3 data, and are therefore representative of the galactic stellar density. The public example currently reproduces the results of Nielsen et al. 2017 and Wagner et al. 2022, demonstrating that the motion of HD 131399A "b" is fit by a finite distance, non-stationary background star, but the code has been tested and validated on proprietary datasets. The code is open source, available on github, and additional contributions are welcome.

[ascl:2307.053]
EVolve: Growth and evolution of volcanically-derived atmospheres

EVolve calculates the chemical composition and surface pressure of a ID atmosphere on a rocky planet that is being produced by volcanic activity, as it grows over time. Once the initial volatile content of the planet's mantle and the composition and resultant surface pressure of any pre-existing atmosphere is set, the volcanic degassing model EVo (ascl:2307.052) calculates the amount and speciation of any volcanic gases released into the atmosphere over each time step. Atmospheric processing is calculated using FastChem (ascl:1804.025); thermochemical equilibrium is assumed so the final chemical composition of the atmosphere is calculated according to the pre-set surface temperature.

[ascl:2307.052]
EVo: Thermodynamic magma degassing model

EVo calculates the speciation and volume of a volcanic gas phase erupting in equilibrium with its parent magma. Models can be run to calculate the gas phase in equilibrium with a melt at a single pressure, or the melt can be decompressed from depth rising to the surface as a closed-system case. Single pressure and decompression can be run for OH, COH, SOH, COHS and COHSN systems. EVo can calculate gas phase weight and volume fraction within the system, gas phase speciation as mole fraction or weight fraction across numerous compounds, and the volatile content of the melt at each pressure. It also calculates melt density, f02 of the system, and more. EVo can be set up using either melt volatile contents, or for a set amount of atomic volatile which is preferable for conducting experiments over a wide range of fO2 values.

[ascl:2307.051]
WeakLensingQML: Quadratic Maximum Likelihood estimator applied to Weak Lensing

WeakLensingQML implements the Quadratic Maximum Likelihood (QML) estimator and applies it to simulated cosmic shear data and compares the results to a Pseudo-Cl implementation. The package computes and saves relevant data files for later processes, such as the fiduciary cosmic shear power spectrum used in the analysis, the sky mask, and computing an analytic version of the QML's covariance matrix. The core of the package implements a conjugate-gradient approach for the quadratic estimator, and is parallelized for maximum performance. The code relies on the Eigen linear algebra package and the HealPix spherical harmonic transform library. A post-processing script analyzes the results and compares the QML's estimates with those from the Pseudo-Cl estimator; it then produces an array of plots highlighting the results.

[ascl:2307.050]
νHawkHunter: Forecasting of PBH neutrinos

νHawkHunter explores the prospects of detecting neutrinos produced by the evaporation of primordial black holes in ground-based experiments. It makes use of neutrino fluxes from Hawking radiation computed with BlackHawk (ascl:2012.020). νHawkHunter is also be used for Diffuse Supernova Neutrino Background or similar studies by replacing the signal fluxes by the proper ones.

[ascl:2307.049]
reMASTERed: Calculate contributions to pseudo-Cl for maps with correlated masks

reMASTERed reconstructs ensemble-averaged pseudo-$C_\ell$ to effectively exact precision, with significant improvements over traditional estimators for cases where the map and mask are correlated. The code can compute the results given an arbitrary map and mask; it can also compute the results in the ensemble average for certain types of threshold masks.

[ascl:2307.048]
NaMaster: Unified pseudo-Cl framework

NaMaster computes full-sky angular cross-power spectra of masked, spin-0 and spin-2 fields with an arbitrary number of known contaminants using a pseudo-Cl (aka MASTER) approach. The code also implements E/B-mode purification and offers both full-sky and flat-sky modes. NaMaster is available as a C library, Python module, and standalone program.

[ascl:2307.047]
GWDALI: Gravitational wave parameter estimation

GWDALI focuses on parameter estimations of gravitational waves generated by compact object coalescence (CBC). This software employs both Gaussian (Fisher Matrix) and Beyond-Gaussian methods to approximate the likelihood of gravitational wave events. GWDALI also addresses the challenges posed by Fisher Matrices with zero determinants. Additionally, the Beyond-Gaussian approach incorporates the Derivative Approximation for Likelihoods (DALI) algorithm, enabling a more reliable estimation process.

[ascl:2307.046]
HAYASHI: Halo-level AnalYsis of the Absorption Signal in HI

HAYASHI (Halo-level AnalYsis of the Absorption Signal in HI) computes the number of absorption features of the 21cm forest using a semianalytic formalism. It includes the enhancement of the signal due to the presence of substructures within minihalos and supports non-standard cosmologies with impact in the large scale structure, such as warm dark matter and primordial black holes. HAYASHI is written in Python3 and uses the cosmological computations package Colossus (ascl:1501.016).

[ascl:2307.045]
NAVanalysis: Normalized Additional Velocity analysis

NAVanalysis studies the non-baryonic, or non-Newtonian, contribution to galaxy rotation curves straight from a given data sample. Conclusions on the radial profile of a given model can be drawn without individual galaxy fits to provide an efficient sample comparison. The method can be used to eliminate model parameter regions, find the most probable parameter regions, and uncover trends not easy to find from standard fits. Further, NAVanalysis can compare different approaches and models.

[ascl:2307.044]
RUBIS: Fast centrifugal deformation program for stellar and planetary models

The centrifugal deformation program RUBIS (Rotation code Using Barotropy conservation over Isopotential Surfaces) takes an input 1D model (with spherical symmetry) and returns its deformed version by applying a conservative rotation profile specified by the user. The code needs only the density as a function of radial distance from the reference model in addition to the surface pressure to be imposed to perform the deformation; preserving the relation between density and pressure when going from the 1D to the 2D structure makes this lightness possible. By solving Poisson's equation in spheroidal rather than spherical coordinates whenever a discontinuity is present, RUBIS can deform both stellar and planetary models, thereby dealing with potential discontinuities in the density profile.

[ascl:2307.043]
EAGLES: Estimating AGes from Lithium Equivalent widthS

EAGLES (Estimating AGes from Lithium Equivalent widthS) implements an empirical model that predicts the lithium equivalent width (EW) of a star as a function of its age and effective temperature. The code computes the age probability distribution for a star with a given EW and Teff, subject to an age probability prior that may be flat in age or flat in log age. Data for more than one star can be entered; EAGLES then treats these as a cluster and determines the age probability distribution for the ensemble. The code produces estimates of the most probable age, uncertainties and the median age; output files consisting of probability plots, best-fit isochrone plots, and tables of the posterior age probability distribution(s).

[ascl:2307.042]
LIMpy: Line Intensity Mapping in Python

Roy, Anirban; Valentín-Martínez, Dariannette; Wang, Kailai; Battaglia, Nicholas; van Engelen, Alexander

LIMpy models and analyzes multi-line intensity maps of CII (158 µ), OIII (88 µ), and CO (1-0) to CO (13-12) transitions. It can be used as an analytic model for star formation rate, to simulate line intensity maps based on halo catalogs, and to calculate the power spectrum from simulated maps and the cross-correlated signal between two separate lines. Among other things, LIMpy can also create multi-line luminosity models and determine the multi-line intensity power spectrum.

[ascl:2307.041]
EFTCAMB: Effective Field Theory with CAMB

EFTCAMB patches the public Einstein-Boltzmann solver CAMB (ascl:1102.026) to implement the Effective Field Theory approach to cosmic acceleration. It can be used to investigate the effect of different EFT operators on linear perturbations and to study perturbations in any specific DE/MG model that can be cast into EFT framework. To interface EFTCAMB with cosmological data sets, it is equipped with a modified version of CosmoMC (ascl:1106.025), EFTCosmoMC, to create a bridge between the EFT parametrization of the dynamics of perturbations and observations.

[ascl:2307.040]
pycrires: Data reduction pipeline for VLT/CRIRES+

pycrires runs the CRIRES+ recipes of EsoRex. The pipeline organizes the raw data, creates SOF and configuration files, runs the calibration and science recipes, and creates plots of the images and extracted spectra. Additionally, it corrects remaining inaccuracies in the wavelength solution and the spectrum curvature. pycrires also provides dedicated routines for the extraction, calibration, and detection of spatially-resolved objects such as directly imaged planets.

[ascl:2307.039]
adiabatic-tides: Tidal stripping of dark matter (sub)haloes

adiabatic-tides evaluates the tidal stripping of dark matter (sub)haloes in the adiabatic limit. It exactly reproduces the remnant of an NFW halo that is exposed to a slowly increasing isotropic tidal field and approximately reproduces the remnant for an anisotropic tidal field. adiabatic-tides also predicts the asymptotic mass loss limit for orbiting subhaloes and differently concentrated host-haloes with and without baryonic components, and can be used to improve predictions of dark matter annihilation.

[ascl:2307.038]
WarpX: Time-based electromagnetic and electrostatic Particle-In-Cell code

Vay, J.L.; Myers, A.; Almgren, A.; Amorim, L. D.; Bell, J.; Fedeli, L.; Ge, L.; Gott, K.; Grote, D. P.; Hogan, M.; Huebl, A.; Jambunathan, R.; Lehe, R.; Ng, C.; Park, J.; Rowan, M.; Shapoval, O.; Thévenet, M.; Vincenti, H.; Yang, E.; Zaïm, N.; Zhang, W.; Zhao, Y.; Zoni, E.

WarpX is an advanced electromagnetic & electrostatic Particle-In-Cell code. It supports many features including Perfectly-Matched Layers (PML), mesh refinement, and the boosted-frame technique. A highly-parallel and highly-optimized code, WarpX can run on GPUs and multi-core CPUs, includes load balancing capabilities, and scales to the largest supercomputers.

[ascl:2307.037]
WDMWaveletTransforms: Fast forward and inverse WDM wavelet transforms

WDMWaveletTransforms implements the fast forward and inverse WDM wavelet transforms in Python from both the time and frequency domains. The frequency domain transforms are inherently faster and more accurate. The wavelet domain->frequency domain and frequency domain->wavelet domain transforms are nearly exact numerical inverses of each other for a variety of inputs tested, including Gaussian random noise. WDMWaveletTransforms has both command line and Python interfaces.

[ascl:2307.036]
binary_c-python: Stellar population synthesis tool and interface to binary_c

binary_c-python provides a manager for and interface to the binary_c framework (ascl:2307.035), and rapidly evolves individual systems and populations of stars. It provides functions such as data processing tools and initial distribution functions for stellar properties. binary_c-python also includes tools to run large grids of (binary) stellar systems on servers or distributed systems.

[ascl:2307.035]
binary_c: Stellar population synthesis software framework

The binary_c software framework models the evolution of single, binary and multiple stars, including stellar evolution and nucleosynthesis. Stellar evolution includes wind mass loss, rotation, thermal pulses, magnetic braking, pre-main sequence evolution, supernovae and kicks, and neutron stars; binary-star evolution includes mass transfer, gravitational-wave losses, tides, novae, circumbinary discs, and merging stars. binary_c natively includes nucleosynthesis, and, as it is designed for stellar population calculations, it is lightweight and versatile. binary_c works in standalone, virtual and HPC environments, and its support software contains tools for development and data analysis. A version in Python, binary_c-python (ascl:2307.036), is also available.

[ascl:2307.034]
Guacho: 3D uniform mesh parallel HD/MHD code for astrophysics

Guacho is a 3D hydrodynamical/magnetohydrodynamical code suited for astrophysical fluids. The hydrodynamic equations are evolved with a number of approximate Riemann solvers. Gaucho includes various modules to deal with different cooling regimes, and a radiation transfer module based on a Monte Carlo ray tracing method. The code can run sequentially or in parallel with MPI.

[ascl:2307.033]
Imber: Doppler imaging tool for modeling stellar and substellar surfaces

Imber simulates spectroscopic and photometric observations with both a gridded numerical simulation and analytical model. Written in Python, it is specifically designed to predict Extremely Large Telescope instrument (such as ELT/METIS and TMT/MODHIS) Doppler imaging performance, and has also been applied to existing, archival observations of spectroscopy and photometry.

[ascl:2307.032]
AmpF: Amplification factor for solar lensing

AmpF numerically calculates the amplification factor for solar lensing. The import parameters are the gravitational-wave frequency and the source angular position with respect to the solar center; the code outputs are the amplification factor and its geometrical-optics limit. AmpF accepts variables for several attributes and the overall amplitude of the lensing potential can be changed as needed. The method has been implemented in both C and Python.

[ascl:2307.031]
HilalPy: Analysis tool for lunar crescent visibility criterion

HilalPy analyzes lunar crescent visibility criteria. Written in Python, the code uses more than 8000 lunar crescent visibility records extracted from literature and websites of lunar crescent observation, descriptive statistics, contradiction rate percentage, and regression analysis in its analysis to predict the visibility of a lunar crescent.

[ascl:2307.030]
SAMUS: Simulator of Asteroid Malformation Under Stress

SAMUS (Simulator of Asteroid Malformation Under Stress) simulates the deformation of minor bodies, assuming that they are homogenous incompressible fluid masses. They are initialized as ellipsoids and the Navier-Stokes equations are interatively solved to investigate the deformation of the body over time. The software is modular and allows for user-defined output functions, size, and trajectories. Structured as a single large class, SAMUS can store variables and handle arbitrary function calls, which eases debugging and investigation, especially for lengthy high-fidelity simulation runs.

[ascl:2307.029]
SIMPLE: Intensity map generator

SIMPLE (Simple Intensity Map Producer for Line Emission) generates intensity maps that include observational effects such as noise, anisotropic smoothing, sky subtraction, and masking. Written in Python, it is based on a lognormal simulation of galaxies and random assignment of luminosities to these galaxies and generates mock intensity maps that can be used to study survey systematics and calculate covariance matrices of power spectra. The code is modular, allowing its components to be used independently.

Would you like to view a random code?