Results 2801-2900 of 3426 (3340 ASCL, 86 submitted)

[ascl:2203.021]
MG-MAMPOSSt: Test gravity with the mass profiles of galaxy clusters

MG-MAMPOSSt extends the MAMPOSSt code (ascl:2203.020), which performs Bayesian fits of models of mass and velocity anisotropy profiles to the distribution of tracers in projected phase space, to handle modified gravity models and constrain its parameters. It implements two distinct types of gravity modifications: general chameleon (including $f(\mathcal{R})$ models), and beyond Horndeski gravity (Vainshtein screening). MG-MAMPOSSt efficently explores the parameter space either by computing the likelihood over a multi-dimensional grid of points or by performing a simple Metropolis-Hastings MCMC. The code requires a Fortran90 compiler or higher and makes use of the getdist package (ascl:1910.018) to plot the marginalized distributions in the MCMC mode.

[ascl:2203.022]
Vetting: Stand-alone tools for vetting transit signals in Kepler, K2 and TESS data

vetting contains simple, stand-alone Python tools for vetting transiting signals in NASA's Kepler, K2, and TESS data. The code performs a centroid test to look for significant changes in the centroid of a star during a transit or eclipse. vetting requires an installation of Python 3.8 or higher.

[ascl:2203.023]
MAGRATHEA: Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics

MAGRATHEA (Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics) is a foundational cosmological library and a relativistic raytracing code. Classical linear algebra libraries come with their own operations and can be difficult to leverage for new data types. Instead of providing basic types, MAGRATHEA provides tools to generate base types such as scalar quantities, points, vectors, or tensors.

[ascl:2203.024]
Magrathea-Pathfinder: 3D AMR ray-tracing in simulations

Magrathea-Pathfinder propagates photons within cosmological simulations to construct observables. This high-performance framework uses a 3D Adaptive-Mesh Refinement and is built on top of the MAGRATHEA metalibrary (ascl:2203.023).

[ascl:2203.025]
SetCoverPy: A heuristic solver for the set cover problem

SetCoverPy finds an (near-)optimal solution to the set cover problem (SCP) as fast as possible. It employs an iterative heuristic approximation method, combining the greedy and Lagrangian relaxation algorithms. It also includes a few useful tools for a quick chi-squared fitting given two vectors with measurement errors.

[ascl:2203.026]
axionCAMB: Modification of the CAMB Boltzmann code

axionCAMB is a modified version of the publicly available code CAMB (ascl:1102.026). axionCAMB computes cosmological observables for comparison with data. This is normally the CMB power spectra (T,E,B,\phi in auto and cross power), but also includes the matter power spectrum.

[ascl:2203.027]
Zoobot: Deep learning galaxy morphology classifier

Walmsley, Mike; Lintott, Chris; Géron, Tobias; Kruk, Sandor; Krawczyk, Coleman; Willett, Kyle W.; Bamford, Steven; Kelvin, Lee S.; Fortson, Lucy; Gal, Yarin; Keel, William; Masters, Karen L.; Mehta, Vihang; Simmons, Brooke D.; Smethurst, Rebecca; Smith, Lewis; Baeten, Elisabeth M.; Macmillan, Christine

Zoobot classifies galaxy morphology with Bayesian CNN. Deep learning models were trained on volunteer classifications; these models were able to both learn from uncertain volunteer responses and predict full posteriors (rather than point estimates) for what volunteers would have said. The code reproduces and improves Galaxy Zoo DECaLS automated classifications, and can be finetuned for new tasks.

[ascl:2203.028]
SimLine: Radiative transfer in molecular lines

SimLine computes the profiles of molecular rotational transitions and atomic fine structure lines in spherically symmetric clouds with arbitrary density, temperature and velocity structure. The code is designed towards a maximum flexibility and very high accuracy based on a completely adaptive discretization of all quantities. The code can treat arbitrary species in spherically symmetric configurations with arbitrary velocity structures and optical depths between about -5 and 5000. Moreover, SimLine includes the treatment of turbulence and clumping effects in a local statistical approximation combined with a radial dependence of the correlation parameters. The code consists of two parts: the self-consistent solution of the balance equations for all level populations and energy densities at all radial points and the computation of the emergent line profiles observed from a telescope with finite beam width and arbitrary offset.

[ascl:2203.029]
Bootsik: Potential field calculator

The Bootsik software generates and visualizes potential magnetic fields. bootsik.f90 generates a potential magnetic field on a 3D mesh, staggered relative to the magnetic potential, by extrapolating the magnetic field normal to the photospheric surface. The code first calculates a magnetic potential using a modified Green’s function method and then uses a finite differencing scheme to calculate the magnetic field from the potential. The IDL script boobox.pro can then be used to visualize the magnetic field.

[ascl:2203.030]
Wigglewave: Linearized governing equations solver

Wigglewave uses a finite difference method to solve the linearized governing equations for a torsion Alfvèn wave propagating in a plasma with negligible plasma beta and in a force-free axisymmetric magnetic field with no azimuthal component embedded in a high density divergent tube structure. Wigglewave is fourth order in time and space using a fourth-order central difference scheme for calculating spatial derivatives and a fourth-order Runge-Kutta (RK4) scheme for updating at each timestep. The solutions calculated are the perturbations to the velocity, v and to the magnetic field, b. All variables are calculated over a uniform grid in radius r and height z.

[ascl:2203.031]
TAWAS: Wave equation solver

TAWAS solves the wave equation for torsional Alfvèn waves in a viscous plasma. The background magnetic field is axisymmetric and force-free with no azimuthal component and the plasma beta is assumed to be negligible. The solution is calculated over a uniform numerical grid with coordinates r and z for the radius and height respectively. TAWAS, written in IDL, requires no input files. The problem parameters at the top of the code can be changed as need. The 'plotting' variable determines which plots are shown by the script; the code contains several options for plotting. Outputs can be saved to a specific location by changing the variables save_dir and run_name listed just below the parameters. The code outputs include solutions for the velocity perturbation, the magnetic field perturbation and the wave energy flux.

[ascl:2204.001]
TG: Turbulence Generator

Turbulence Generator generates a time sequence of random Fourier modes via an Ornstein-Uhlenbeck (OU) process, used to drive turbulence in hydrodynamical simulation codes. It can also generate single turbulent realizations. Turbulence driving based on this method is currently supported by implementations in AREPO (ascl:1909.010), FLASH (ascl:1010.082), GADGET (ascl:0003.001), PHANTOM (ascl:1709.002), PLUTO (ascl:1010.045), and Quokka (ascl:2110.009).

[ascl:2204.002]
Astroplotlib: Python scripts to handle astronomical images

Astroplotlib builds images with any scale, overlay contours, physical bars, and orientation arrows (N and E axes) automatically. The package contains scripts to overlay pseudo-slits and obtain statistics from apertures, estimate the background sky, and overlay the fitted isophotes and their respective contours on an image. Astroplotlib can work with the output table from the Ellipse task of IRAF and overlay fitted isophotes and their respective contours. It includes a GUI for masking areas in the images by using different polygons, and can also obtain statistical information (*e.g.*, total flux and mean, among others) from the masked areas. There is also a GUI to overlay star catalogs on an image and an option to download them directly from the Vizier server.

[ascl:2204.003]
legacystamps: Retrieve DESI Legacy Imaging Surveys cutouts

The Python module legacystamps provides easy retrieval, both standalone and scripted, of FITS and JPEG cutouts from the DESI Legacy Imaging Surveys through URLs provided by the Legacy Survey viewer.

[ascl:2204.004]
Bayesian SZNet: Bayesian deep learning to predict redshift with uncertainty

Bayesian SZNet predicts spectroscopic redshift through use of a Bayesian convolutional network. It uses Monte Carlo dropout to associate predictions with predictive uncertainties, allowing the user to determine unusual or problematic spectra for visual inspection and thresholding to balance between the number of incorrect redshift predictions and coverage.

[ascl:2204.005]
TESS-Localize: Localize variable star signatures in TESS Photometry

TESS-Localize identifies the location on the target pixel files (TPF) where sources of variability found in the aperture originate. The user needs only to provide a list of frequencies found in the aperture that belong to the same source and the number of principal components needed to be removed from the light curve to ensure it is free of systematic trends.

[ascl:2204.006]
dsigma: Galaxy-galaxy lensing Python package

dsigma analyzes galaxy-galaxy lensing. Written in Python, it has a broadly applicable API and is optimized for computational efficiency. While originally intended to be used with the shape catalog of the Hyper-Suprime Cam (HSC) survey, it should work for other surveys, most prominently the Dark Energy Survey (DES) and the Kilo-Degree Survey (KiDS).

[ascl:2204.007]
RTS: Radio Transient Simulations

Radio Transient Simulations uses Monte-Carlo simulations to accurately determine transient rates in radio surveys. The user inputs either a real or simulated observational setup, and the simulations code calculates transient rate as a function of transient duration and peak flux. These simulations allow for simulating a wide variety of scenarios including observations with varying sensitivities and durations, multiple overlapping telescope pointings, and a wide variety of light curve shapes with the user having the ability to easily add more. Though the current scientific focus is on the radio regime, the simulations code can be easily adapted to other wavelength regimes.

[ascl:2204.008]
RMNest: Bayesian approach to measuring Faraday rotation and conversion in radio signals

RMNest directly fits the Stokes Q and U (and V) spectra of a radio signal to measure the effects of Faraday rotation (or conversion) induced by propagation through a magnetized plasma along the line of sight. The software makes use of the Bayesian Inference Library (Bilby; ascl:1901.011) as an interface to the dynesty (ascl:1809.013) nested sampling algorithm.

[ascl:2204.009]
MAYONNAISE: ADI data imaging processing pipeline

MAYONNAISE (Morphological Analysis Yielding separated Objects iN Near infrAred usIng Sources Estimation), or MAYO for short, is a pipeline for exoplanet and disk high-contrast imaging from ADI datasets. The pipeline is mostly automated; the package also loads the data and injects synthetic data if needed. MAYONNAISE parameters are written in a json file called parameters_algo.json and placed in a working_directory.

[ascl:2204.010]
FBCTrack: Fragmentation and bulk composition tracking

The fragmentation and bulk composition tracking package contains two codes. The fragmentation code models fragmentation in collisions for the C version of REBOUND (ascl:1110.016). This code requires setting two global parameters. It automatically produces a collision report that details the time of every collision, the bodies involved, how the collision was resolved, and how many fragments were produced; collision outcomes are assigned a numerical value. The bulk composition tracking code tracks the composition change as a function of mass exchange for bodies with a homogenous composition. It is a post-processing code that works in conjunction with the fragmentation code, and requires the collision report generated by the fragmentation code.

[ascl:2204.011]
SimAb: Planet formation model

SimAb (Simulating Abundances) simulates planet formation, focusing on the atmosphere accretion of gas giant planets. The package can run the simulation in two different modes. The single simulation mode is run by specifying the initial conditions (the core mass, the initial orbital distance, the planetesimal ratio, and the dust grain fraction), and the mature planet mass and orbital distance. The multi run simulation mode requires specifying the mass and the final orbital distance of the mature planet; the simulation randomly assigns initial orbital distance, initial core mass, initial planetesimal ratio, and initial dust grain fraction. The package also provides Jupyter codes for plotting the results of the simulations.

[ascl:2204.012]
SpECTRE: Multi-scale, multi-physics problem solver

Deppe, Nils; Throwe, William; Kidder, Lawrence E.; Vu, Nils L.; Hébert, François; Moxon, Jordan; Armaza, Cristóbal; Bonilla, Gabriel S.; Kim, Yoonsoo; Kumar, Prayush; Lovelace, Geoffrey; Macedo, Alexandra; Nelli, Kyle C.; O'Shea, Eamonn; Pfeiffer, Harald P.; Scheel, Mark A.; Teukolsky, Saul A.; Wittek, Nikolas A.; Anantpurkar, Isha; Boyle, Michael; Carpenter, Alexander; Chaudhary, Himanshu; Foucart, Francois; Ghadiri, Noora; Giesler, Matthew; Guo, Jason S.; Iozzo, Dante A. B.; Legred, Isaac; Li, Dongjun; Ma, Sizheng; Melchor, Denyz; Morales, Marlo; Ramirez, Teresita; Rüter, Hannes R.; Sanchez, Jennifer; Thomas, Sierra; Vieira, Daniel; Wlodarczyk, Tom

SpECTRE solves multi-scale, multi-physics problems in astrophysics and gravitational physics, such as those associated with the multi-messenger astrophysics of neutron star mergers, core-collapse supernovae, and gamma-ray bursts. It runs at petascale and is designed for future exascale computers.

[ascl:2204.013]
SCRIPT: Semi-numerical Code for ReIonization with PhoTon-conservation

SCRIPT (Semi-numerical Code for ReIonization with PhoTon-conservation) generates the ionization field during the epoch of cosmological reionization using a photon-conserving algorithm. The code depends on density and velocity files obtained using a N-body simulation, which can be generated with a 2LPT code such as MUSIC (ascl:1311.011).

[ascl:2204.014]
GADGET-4: Parallel cosmological N-body and SPH code

GADGET-4 (GAlaxies with Dark matter and Gas intEracT) is a parallel cosmological N-body and SPH code that simulates cosmic structure formation and calculations relevant for galaxy evolution and galactic dynamics. It is massively parallel and flexible, and can be applied to a variety of different types of simulations, offering a number of sophisticated simulation algorithms. GADGET-4 supports collisionless simulations and smoothed particle hydrodynamics on massively parallel computers.

The code can be used for plain Newtonian dynamics, or for cosmological integrations in arbitrary cosmologies, both with or without periodic boundary conditions. Stretched periodic boxes, and special cases such as simulations with two periodic dimensions and one non-periodic dimension are supported as well. The modeling of hydrodynamics is optional. The code is adaptive both in space and in time, and its Lagrangian character makes it particularly suitable for simulations of cosmic structure formation. Several post-processing options such as group- and substructure finding, or power spectrum estimation are built in and can be carried out on the fly or applied to existing snapshots. Through a built-in cosmological initial conditions generator, it is also particularly easy to carry out cosmological simulations. In addition, merger trees can be determined directly by the code.

[ascl:2204.015]
ADBSat: Aerodynamic Database for Satellites

Sinpetru, Luciana A.; Crisp, Nicholas H.; Roberts, Peter C. E.; Sulliotti-Linner, Valeria; Hanessian, Virginia; Herdrich, Georg H.; Romano, Francesco; Garcia-Almiñana, Daniel; Rodríguez-Donaire, Sílvia; Seminari, Simon; Mostaza-Prieto, David; Livadiotti, Sabrina

ADBSat computes aerodynamic coefficient databases for satellite geometries in free-molecular flow (FMF) conditions. Written in MATLAB, ADBSat imports body geometry from .stl or .obj mesh files, calculates aerodynamic force and moment coefficient for different gas-surface interaction models, and calculates solar radiation pressure force and moment coefficient. It also takes multiple surface and material characteristics into consideration. ADBSat is a panel-method tool that is able to calculate aerodynamic or solar force and moment coefficient sets for satellite geometries by applying analytical (closed-form) expressions for the interactions to discrete flat-plate mesh elements. The panel method of ADBSat assumes FMF conditions. The code analyzes basic shadowing to identify panels that are shielded from the flow by other parts of the body and will therefore not experience any surface interactions. However, this method is dependent on the refinement of the input mesh and can be sensitive to the orientation and arrangement of the mesh elements with respect to the oncoming flow direction.

[ascl:2204.016]
pySIDES: Simulated Infrared Dusty Extragalactic Sky in Python

pySIDES generates mock catalogs of galaxies in the (sub-)millimeter domain and associates spectral cubes (e.g., for intensity mapping experiments). It produces both continuum and CO, [CII], and [CI] line emissions. pySIDES is the Python version of the Simulated Infrared Dusty Extragalactic Sky (SIDES).

[ascl:2204.017]
RSG: Redshift Search Graphs

Redshift Search Graphs provides a fast and reliable way to test redshifts found from sub-mm redshift searches. The scripts can graphically test the robustness of a spectroscopic redshift of a galaxy, test the efficiency of an instrument towards spectroscopic redshift searches, and optimize observations of tunable institutes (such as ALMA) for upcoming redshift searches.

[ascl:2204.018]
ProFuse: Galaxies and components modeler

ProFuse produces physical models of galaxies and their components by combining the functionalities of the source extraction code PROFOUND (ascl:1804.006), the Bayesian galaxy fitting tool ProFit (ascl:1612.004), and the spectral generation package ProSpect (ascl:2002.007). ProFuse uses a self-consistent model for the star formation and metallicity history of the bulge and disk separately to generate images. The package then defines the model likelihood and optimizes the physical galaxy reconstruction using target images across a range of wavelengths.

[ascl:2204.019]
DarkFlux: Dark Matter annihilation spectrum computer

DarkFlux analyzes indirect-detection signatures for next-generation models of dark matter (DM) with multiple annihilation channels. Input is user-generated models with 2 → 2 tree-level dark matter annihilation to pairs of Standard Model (SM) particles. The code analyzes DM annihilation to γ rays using three modules; one computes the fractional annihilation rate, the second computes the total flux at Earth due to DM annihilation, and the third compares the total flux to observational data and computes the upper limit at 95% confidence level (CL) on the total thermally averaged DM annihilation cross section.

[ascl:2204.020]
MonoTools: Planets of uncertain periods detector and modeler

MonoTools detects, vets, and models transiting exoplanets, with a specific emphasis on monotransiting planets and those with unknown periods. It includes scripts specifically for searching and assessing a lightcurve for the presence of monotransits. MonoTools can also performing a best-fit transit model, determine whether transits are linked to any detected multi-transiting planet candidate or with each other, and can fit planets in a Bayesian way to account for uncertain periods, lightcurve gaps, and stellar variability, among other things.

[submitted]
SWIFTGalaxy

SWIFTGalaxy provides a software abstraction of simulated galaxies produced by the SWIFT smoothed particle hydrodynamics code. It extends the SWIFTSimIO module and is tailored to analyses of particles belonging to individual simulated galaxies. It inherits from and extends the functionality of the SWIFTDataset. It understands the output of halo finders and therefore which particles belong to a galaxy, and its integrated properties. The particles occupy a coordinate frame that is enforced to be consistent, such that particles loaded on-the-fly will match e.g. rotations and translations of particles already in memory. Intuitive masking of particle datasets is also enabled. Finally, some utilities to make working in cylindrical and spherical coordinate systems more convenient are also provided.

[submitted]
Python “sgp4” module that offers official SGP4 C++ library

The “sgp4” module is a Python wrapper around the C++ version of the standard SGP4 algorithm for propagating Earth satellite positions from the element sets published by organizations like SpaceTrak and Celestrak. The code is the most recent version, including all of the corrections and bug fixes described in the paper _Revisiting Spacetrack Report #3_ (AIAA 2006-6753) by Vallado, Crawford, Hujsak, and Kelso. The test suite verifies that the Python wrapper returns exactly the coordinates specified in the C++ test cases.

[ascl:2205.001]
PMOIRED: Parametric Modeling of Optical Interferometric Data

PMOIRED models astronomical spectro-interferometric data stored in the OIFITS format. Parametric modeling is used to describe the observed scene as blocks such as disks, rings and Gaussians which can be combined and their parameters linked. It includes plotting, least-square fitting and bootstrapping estimation of uncertainties. For spectroscopic instruments (such as GRAVITY), tools are provided to model spectral lines and correct spectra for telluric lines.

[ascl:2205.002]
am: Microwave through submillimeter-wave propagation tool for the terrestrial atmosphere

am performs optical depth, radiative transfer, and refraction computations involving propagation through the terrestrial atmosphere and other media at microwave through submillimeter wavelengths. The program is used in radio astronomy, atmospheric radiometry, and radio spectrum management.

[ascl:2205.003]
QSOGEN: Model quasar SEDs

The QSOGEN collection of Python code models quasar colors, magnitudes and SEDs. It implements an empirically-motivated parametric model to efficiently account for the observed emission-line properties, host-galaxy contribution, dust reddening, hot dust emission, and IGM suppression in the rest-frame 900-30000A wavelength range for quasars with a wide range of redshift and luminosity.

The code is packaged with a set of empirically-derived emission-line templates and an empirically-derived quasar dust extinction curve which are publicly released.

[ascl:2205.004]
FAlCon-DNS: Framework of time schemes for direct numerical simulation of annular convection

FAlCon-DNS (Framework of time schemes for direct numerical simulation of annular convection) solves for 2-D convection in an annulus and analyzes different time integration schemes. The framework contains a suite of IMEX, IMEXRK and RK time integration schemes. The code uses a pseudospectral method for spatial discretization. The governing equations contain both numerically stiff (diffusive) and non-stiff (advective) components for time discretization. The software offers OpenMP for parallelization.

[ascl:2205.005]
maelstrom: Forward modeling of pulsating stars in binaries

Hey, Daniel R.; Murphy, Simon J.; Foreman-Mackey, Dan; Bedding, Timothy R.; Pope, Benjamin J.S.; Hogg, David W.

maelstrom models binary orbits through the phase modulation technique. This set of custom PyMC3 models and solvers fit each individual datapoint in the time series by forward modeling the time delay onto the light curve. This approach fully captures variations in a light curve caused by an orbital companion.

[ascl:2205.006]
LATTE: Lightcurve Analysis Tool for Transiting Exoplanet

LATTE identifies, vets and characterizes signals in TESS lightcurves to weed out instrumental and astrophysical false positives. The program performs a fast in-depth analysis of targets that have already been identified as promising candidates by the main TESS pipelines or via alternative methods such as citizen science. The code automatically downloads the data products for any chosen TIC ID (short or long cadence TESS data) and produces a number of diagnostic plots that are compiled in a concise report.

[ascl:2205.007]
EarthScatterLikelihood: Event rates and likelihoods for Dark Matter direct detection in the presence of Earth-Scattering

EarthScatterLikelihood calculates event rates and likelihoods for Earth-scattering Dark Matter. It is written in Fortran with plotting routines in Python. For input, it uses results from Monte Carlo simulations generated by DaMaSCUS (ascl:1706.003). It includes routines for submitting many reconstructions in parallel on a cluster, and the properties of the detector, such as for a Germanium and a Sapphire detector, can be edited.

[ascl:2205.008]
Hyperopt: Distributed asynchronous hyper-parameter optimization

The Python library Hyperopt performs serial and parallel optimization over awkward search spaces, which may include real-valued, discrete, and conditional dimensions. Three algorithms are implemented in hyperopt: Random Search, Tree of Parzen Estimators (TPE), and Adaptive TPE. Algorithms can be parallelized in two ways, using either Apache Spark or MongoDB. To use Hyperopt, the objective function to minimize and the space over which to search, and the database in which to store all the point evaluations of the search have to be described, and the search algorithm to use has to be specified.

[ascl:2205.009]
hyperas: Keras + Hyperopt

Hyperas is a convenience wrapper around hyperopt (ascl:2205.008) for fast prototyping with keras models (ascl:1806.022). Hyperas lets you use the power of hyperopt without having to learn the syntax of it. Instead, just define your keras model as you are used to, but use a simple template notation to define hyper-parameter ranges to tune.

[ascl:2205.010]
pyICs: Initial Conditions creator for isolated galaxy formation simulations

pyICs creates initial condition (IC) files for N-body simulations of the formation of isolated galaxies. It uses the pynbody analysis package (ascl:1305.002) to create the actual IC files. pyICs generates dark matter halos (DM) in dynamical equilibrium which host a rotating gas sphere. The DM particle velocities are drawn from the equilibrium distribution function and the gas sphere has an angular momentum profile. The DM and the gas share the same 3D radial density profile. The code natively supports the αβγ-models: ρ ~ (r/a)-γ[1+(r/a)α](γ-β)/α. If γ <= 3, the profiles are smoothly truncated outside the virial radius. The radial profile can be arbitrary as long as python functions for the profile itself and its first and second derivative with radius are given.

[ascl:2205.011]
myRadex: Radex with a twist

myRadex solves essentially the same problem as RADEX (ascl:1010.075), except that it takes a different approach to solve the statistical equilibrium problem. Given an initial distribution, myRadex evolves the system towards equilibrium using an ODE solver. Frequencies in the input file are used by default, and a function for calculating critical densities of all the transitions of a molecule is included.

[ascl:2205.012]
Zelda: Generate correlation functions and power spectra from a galaxy catalog

The Zelda command-line tool extracts correlation functions in velocity space from a galaxy catalog. Zelda is modular, extendable, and can be generalized to produce power spectra and to work in position space. Written in C, it was heavily inspired by the cosmological Boltzmann code CLASS (ascl:1106.020). Zelda is a parallel code using the OpenMP standard.

[ascl:2205.013]
ld-exosim: Simulate biases using different limb darkening laws

ld-exosim selects the optimal (*i.e.* best estimator in a MSE sense) limb-darkening law for a given transiting exoplanet lightcurve and calculates the limb-darkening induced biases on various exoplanet parameters. Limb-darkening laws include linear, quadratic, logarithmic, square-root and three-parameter laws.

[ascl:2205.014]
FHD: Fast Holographic Deconvolution

Sullivan, Ian; Barry, Nichole; Byrne, Ruby L.; Morales, Miguel F.; Hazelton, Bryna; Beardsley, Adam; Lanman, Adam

FHD is an open-source imaging algorithm for radio interferometers and is written in IDL. The three main use-cases for FHD are efficient image deconvolution for general radio astronomy, fast-mode Epoch of Reionization analysis, and simulation. FHD inputs beam models, calibration files, and sky model catalogs and requires input data to be in uvfits format.

[ascl:2205.015]
CS-ROMER: Compressed Sensing ROtation MEasure Reconstruction

CS-ROMER (Compressed Sensing ROtation MEasure Reconstruction) is a compressed sensing reconstruction framework for Faraday depth spectra. It can simulation Faraday depth sources, subtract Galactic RM, and reconstruct Faraday depth sources from linearly polarized data and Faraday depth sources using Compressed Sensing.

[ascl:2205.016]
Pryngles: PlanetaRY spaNGLES

Pryngles produces visualizations of the geometric configuration of a ringed exoplanet (an exoplanet with a ring or exoring for short) and calculates the light-curve signatures produced by these kind of planets. The model behind the package has been developed in an effort to predict the signatures that exorings may produce not only in the light-curve of transiting exoplanets (a problem that has been extensively studied) but also in the light of stars having non-transiting exoplanets.

[ascl:2205.017]
LiSA: LIghtweight Source finding Algorithms for analysis of HI spectral data

The LIghtweight Source finding Algorithms (LiSA) library finds HI sources in next generation radio surveys. LiSA can analyze input data cubes of any size with pipelines that automatically decompose data into different domains for parallel distributed analysis. For source finding, the library contains python modules for wavelet denoising of 3D spatial and spectral data, and robust automatic source finding using null-hypothesis testing. The source-finding algorithms all have options to automatically choose parameters, minimizing the need for manual fine tuning. Finally, LiSA also contains neural network architectures for classification and characterization of 3D spectral data.

[ascl:2205.018]
ASOHF: Adaptive Spherical Overdensity Halo Finder

ASOHF (Adaptive Spherical Overdensity Halo Finder) identifies bound dark matter structures (dark matter haloes) in the outputs of cosmological simulations, and works directly on an input particle list. The computational cost of running ASOHF in simulations with a large number of particles can be reduced by using a domain decomposition to split the simulation box into smaller boxes, or subdomains, which are then processed independently. The basic output of ASOHF is a halo catalog. The package includes a python code to build a merger tree from ASOHF outputs.

[ascl:2205.019]
HOPS: Haystack Observatory Postprocessing System

Whitney, A. R.; Cappallo, R.; Aldrich, W.; Anderson, B.; Bos, A.; Casse, J.; Goodman, J.; Parsley, S.; Pogrebenko, S.; Schilizzi, R.; Smythe, D.

HOPS (Haystack Observatory Postprocessing System) analyzes the data generated by DiFX VLBI correlators. It is written in C for Linux computers, and emphasizes quality-control aspects of data processing. It sits between the correlator and an image-processing and/or geodetic-processing package, and performs basic fringe-fitting, data editing, problem diagnosis, and correlator support functions.

[ascl:2205.020]
ASTROMER: Building light curves embeddings using transfomers

ASTROMER is a Transformer-based model trained on millions of stars for the representation of light curves. Pretrained models can be directly used or finetuned on specific datasets. ASTROMER is useful in downstream tasks in which data are limited to train deep learning models.

[ascl:2205.021]
CPNest: Parallel nested sampling

CPNest performs Bayesian inference using the nested sampling algorithm. It is designed to be simple for the user to provide a model via a set of parameters, their bounds and a log-likelihood function. An optional log-prior function can be given for non-uniform prior distributions. The nested sampling algorithm is then used to compute the marginal likelihood or evidence. As a by-product the algorithm produces samples from the posterior probability distribution. The implementation is based on an ensemble MCMC sampler which can use multiple cores to parallelize computation.

[ascl:2205.022]
BANG: BAyesian decomposiotioN of Galaxies

Rigamonti, Fabio; Dotti, Massimo; Covino, Stefano; Haardt, Francesco; Landoni, Marco; Del Pozzo, Walter; Lupi, Alessandro; Zibetti, Stefano

BANG (BAyesian decomposiotioN of Galaxies) models both the photometry and kinematics of galaxies. The underlying model is the superposition of different components with three possible combinations: 1.) Bulge + inner disc + outer disc + Halo; 2.) Bulge + disc + Halo; and 3.) inner disc + outer disc + Halo. As CPU parameter estimation can take days, running BANG on GPU is recommended.

[ascl:2205.023]
PyWPF: Waterfall Principal Component Analysis (PCA) Folding

Cassanelli, Tomas; Naletto, Giampiero; Codogno, Giacomo; Barbieri, Cesare; Verroi, Enrico; Zampieri, Luca

PyWPF (Waterfall Principal Component Analysis Folding) finds periodicity in one-dimensional timestream data sets; it is particularly designed for very high noise situations where traditional methods may fail. Given a timestream, with each point being the arrival times of a source, the software computes the estimated period. The core function of the package requires several initial parameters to run, and using the best known period of the source (T_init) is recommended.

[ascl:2205.024]
MM-LSD: Multi-Mask Least-Squares Deconvolution

Lienhard, F.; Mortier, A.; Buchhave, L.; Collier Cameron, A.; López-Morales, M.; Sozzetti, A.; Watson, C. A.; Cosentino, R.

MM-LSD (Multi-Mask Least-Squares Deconvolution) performs continuum normalization of 2D spectra (echelle order spectra). It also masks and partially corrects telluric lines and extracts RVs from spectra. The code requires RASSINE (ascl:2102.022) and uses spectral line data from VALD3.

[ascl:2205.025]
simulateSearch: High-time resolution data sets simulations for radio telescopes

simulateSearch simulates high time-resolution data in radio astronomy. The code is built around producing multiple binary data files that contain information on the radiometer noise and sources that are being simulated. These binary data files subsequently get combined and output PSRFITS

search mode files produced. The PSRFITS files can be processed using standard pulsar software packages such as PRESTO (ascl:1107.017).

[ascl:2206.001]
vortex: Helmholtz-Hodge decomposition for an AMR velocity field

vortex performs a Helmholtz-Hodge decomposition on vector fields defined on AMR grids, decomposing a vector field in its solenoidal (divergence-less) and compressive (curl-less) parts. It works natively on vector fields defined on Adaptive Mesh Refinement (AMR) grids, so that it can perform the decomposition over large dynamical ranges; it is also applicable to particle-based simulations. As vortex is devised primarily to investigate the properties of the turbulent velocity field in the Intracluster Medium (ICM), it also includes routines for multi-scale filtering the velocity field.

[ascl:2206.002]
TCF: Transit Comb Filter periodogram

TCF calculates a periodogram designed to detect exoplanet transits after the light curve has been differenced. It is a matched filter for a periodic double-spike pattern. The difference operator that can be used independently for detrending a light curve; it is also embedded in ARIMA (autoregressive integrated moving average) Box-Jenkins modeling.

[submitted]
Green Bank Observatory Gridder

A stand-alone spectral gridder and imager for the Green Bank Telescope, as well as functionality for any diameter telescope. Based around the cygrid package from Benjamin Winkel and Daniel Lenz

[ascl:2206.003]
ExoJAX: Spectrum modeling of exoplanets and brown dwarfs

Kawahara, Hajime; Kawashima, Yui; Masuda, Kento; Crossfield, Ian; van den Bekerom, Dirk; Kitzmann, Daniel; Morris, Brett; Pannier, Erwan; Nugroho, Stevanus; Ishikawa,Tako

ExoJAX provides auto-differentiable line-by-line spectral modeling of exoplanets/brown dwarfs/M dwarfs using JAX (ascl:2111.002). In a nutshell, ExoJAX allows the user to do a HMC-NUTS fitting using the latest molecular/atomic data in ExoMol, HITRAN/HITEMP, and VALD3. The code enables a fully Bayesian inference of the high-dispersion data to fit the line-by-line spectral computation to the observed spectrum, from end-to-end (i.e. from molecular/atomic databases to real spectra), by combining it with the Hamiltonian Monte Carlo in recent probabilistic programming languages such as NumPyro.

[ascl:2206.004]
pystortion: Distortion measurement support

pystortion provides support for distortion measurements in astronomical imagers. It includes classes to support fitting of bivariate polynomials of arbitrary degree and helper functions for crossmatching catalogs. The crossmatching uses an iterative approach in which a two-dimensional distortion model is fit at every iteration and used to continuously refine the position of extracted sources.

[ascl:2206.005]
NonnegMFPy: Nonnegative Matrix Factorization with heteroscedastic uncertainties and missing data

NonnegMFPy solves nonnegative matrix factorization (NMF) given a dataset with heteroscedastic uncertainties and missing data with a vectorized multiplicative update rule; this can be used create a mask and iterate the process to exclude certain new data by updating the mask. The code can work on multi-dimensional data, such as images, if the data are first flattened to 1D.

[ascl:2206.006]
MYRaf: Aperture photometry GUI for IRAF

MYRaf is a practicable astronomical image reduction and photometry software and interface for IRAF (ascl:9911.002). The library uses IRAF, PyRAF (ascl:1207.011), Ginga (ascl:1303.020), and other python packages with a Qt framework for automated software processing of data from robotic telescopes.

[ascl:2206.007]
CircleCraters: Crater-counting plugin for QGIS

CircleCraters is a projection independent crater counting plugin for QGIS. It has the flexibility to crater count in a GIS environment on Windows, OS X, or Linux, and uses three-click input to define crater rims as a circle.

[ascl:2206.008]
Craterstats2: Planetary surface dating from crater size-frequency distribution measurements

Craterstats2 plots crater counts and determining surface ages. The software plots isochrons in cumulative, differential, R-plot and Hartmann presentations, and makes isochron fits to both cumulative and differential data. Hartmann-style piecewise production functions may also be used. A Python implementation of the software, Craterstats3, is also available.

[ascl:2206.009]
Craterstats3: Analyze and plot crater count data for planetary surface dating

Craterstats3 analyzes and plots crater count data for planetary surface dating. It is a Python implementation of Craterstats2 (ascl:2206.008) and is designed to replicate the output of the previous version as closely as possible. As before, it produces plots in cumulative, differential, Hartmann, and R-plot styles with possible overlays of crater counts, isochrons, equilibrium functions and epoch boundaries, as well aschronology and impact rate functions. Data can be shown with various binnings or unbinned, and age estimates made by either cumulative fitting, differential fitting, or Poisson timing evaluation. Numerical results can be output as text for further processing elsewhere. A number of published chronology systems are already set up for use, but new ones may be added by the user. The software is designed to be easily integrated into other software, which could allow the addition of a graphical interface or the inclusion of some Craterstats functions into a GIS.

[ascl:2206.010]
pyHIIexplorerV2: Integrated spectra of HII regions extractor

Espinosa-Ponce, C.; Sánchez, S. F.; Morisset, C.; Barrera-Ballesteros, J. K.; Galbany, L.; García-Benito, R.; Lacerda, E. A. D.; Mast, D.

pyHIIexplorerV2 extracts the integrated spectra of HII regions from integral field spectroscopy (IFS) datacubes. The detection of HII regions performed by pyHIIexplorer is based on two assumptions: 1) HII regions have strong emission lines that are clearly above the continuum emission and the average ionized gas emission across each galaxy, and 2) the typical size of HII regions is about a few hundreds of parsecs, which corresponds to a usual projected size of a few arcsec at the distance of our galaxies. These assumptions will define clumpy structures with a high Ha emission line contrast in comparison to the continuum. pyHIIexplorerV2 is written in Python; it is based on and is a successor to HIIexplorer (ascl:1603.017).

[submitted]
fastrometry: Fast world coordinate solution solver

Fastrometry is a Python implementation of the fast world coordinate solution solver for the FITS standard astronomical image. When supplied with the approximate field center (+-25%) and the approximate field scale (+-10%) of the telescope and detector system the astronomical image is from, fastrometry provides WCS solutions almost instantaneously. The algorithm is also originally implemented with parallelism enabled in the Windows FITS image processor and viewer CCDLAB (ascl:2206.021).

[submitted]
JPFITS (C# .Net FITS File Interaction)

FITS File interaction written in Visual Studio C# .Net.

JPFITS is not based upon any other implementation and is written from the ground-up, consistent with the FITS standard, designed to interact with FITS files as object-oriented structures.

JPFITS provides functionality to interact with FITS images and binary table extensions, as well as providing common mathematical methods for the manipulation of data, data reductions, profile fitting, photometry, etc.

JPFITS also implements object-oriented classes for Point Source Extraction, World Coordinate Solutions (WCS), WCS automated field solving, FITS Headers and Header Keys, etc.

The automatic world coordinate solver is based on the trigonometric algorithm as described here:

https://iopscience.iop.org/article/10.1088/1538-3873/ab7ee8

All function parameters, methods, properties, etc., are coded with XML descriptions which will function with Visual Studio. Other code editors may or may not read the XML files.

Everything which is reasonable to parallelize in order to benefit from the computation speed increase for multi-threaded systems has been done so. In all such cases function options are given in order to specify the use of parallelism or not. Generally, most image manipulation functions are highly amenable to parallelism. No parallelism is forced, i.e., any code which may execute parallelized is given a user option to do so or not.

[ascl:2206.011]
IFSCube: Analyze and process integral field spectroscopy data cubes

IFSCube performs analysis tasks in data cubes of integral field spectroscopy. It contains routines for fitting spectral features in 1D spectra and data cubes and rotation models to velocity fields; it also contains a routine that inspects the fit results. Though originally intended to make user scripts more concise, analysis can also be performed on the fly by using an interactive interpreter such as ipython. By default, IFSCube assumes data are in the Flexible Image Transport System (FITS) standard, but the package can be modified easily to allow use of other data formats.

[ascl:2206.012]
WDPhotTools: White Dwarf Photometric SED fitter and luminosity function builder

WDPhotTools generates color-color diagrams and color-magnitude diagrams in various photometric systems, plots cooling profiles from different models, and computes theoretical white dwarf luminosity functions based on the built-in or supplied models of the (1) initial mass function, (2) total stellar evolution lifetime, (3) initial-final mass relation, and (4) white dwarf cooling time. The software has three main parts: the formatters that handle the output models from various works in the format as they are downloaded; the photometric fitter that solves for the WD parameters based on the photometry, with or without distance and reddening; and the generator of the white dwarf luminosity function in bolometric magnitudes or in any of the photometric systems available from the atmosphere model.

[ascl:2206.013]
smooth: Smoothing for N-body simulations

Smooth calculates several mean quantities for all particles in an N-Body simulation output file. The program produces a file for each type of output specified on the command line. This output file is in ASCII format with one smoothed quantity for each particle. The program uses a symmetric SPH (Smoothed Particle Hydrodynamics) smoothing kernel to find the mean quantities.

[ascl:2206.014]
SpinSpotter: Stellar rotation periods from high-cadence photometry calculator

SpinSpotter calculates stellar rotation periods from high-cadence photometry. The code uses the autocorrelation function (ACF) to identify stellar rotation periods up to one-third the observational baseline of the data. SpinSpotter includes diagnostic tools that describe features in the ACF and allows tuning of the tolerance with which to accept a period detection.

[ascl:2206.015]
Smart: Automatic differentiation of accelerations and variational equations

Smart provides pre-processing for LP-VIcode (ascl:1501.007). It computes the accelerations and variational equations given a generic user-defined potential function, eliminating the need to calculate manually the accelerations and variational equations.

[ascl:2206.016]
wdwarfdate: White dwarfs age calculator

wdwarfdate derives the Bayesian total age of a white dwarf from an effective temperature and a surface gravity. It runs a chain of models assuming single star evolution and estimates the following parameters and their uncertainties: total age of the object, mass and cooling age of the white dwarf, and mass and lifetime of the progenitor star.

[ascl:2206.017]
atoMEC: Average-Atom code for Matter under Extreme Conditions

Callow, Timothy; Kotik, Daniel; Tsvetoslavova Stankulova, Ekaterina; Rahat, Nathan; Kraisler, Eli; Cangi, Attila

atoMEC simulates high energy density phenomena such as in warm dense matter. It uses Kohn-Sham density functional theory, in combination with an average-atom approximation, to solve the electronic structure problem for single-element materials at finite temperature.

[ascl:2206.018]
MADYS: Isochronal parameter determination for young stellar and substellar objects

MADYS (Manifold Age Determination for Young Stars) determines the age and mass of young stellar and substellar objects. The code automatically retrieves and cross-matches photometry from several catalogs, estimates interstellar extinction, and derives age and mass estimates for individual objects through isochronal fitting. MADYS harmonizes the heterogeneity of publicly-available isochrone grids and the user can choose amongst several models, some of which have customizable astrophysical parameters. Particular attention has been dedicated to the categorization of these models, labeled through a four-level taxonomical classification.

[ascl:2206.019]
SEVN: Stellar EVolution for N-body

The population synthesis code SEVN (Stellar EVolution for N-body) includes up-to-date stellar evolution (through look-up tables), binary evolution, and different recipes for core-collapse supernovae. SEVN also provides an up-to-date formalism for pair-instability and pulsational pair-instability supernovae, and is designed to interface with direct-summation N-body codes such as STARLAB (ascl:1010.076) and HiGPUs (ascl:1207.002).

[ascl:2206.020]
CCDLAB: FITS image viewer and data reducer

CCDLAB provides graphical user interface functionality for FITS image viewing and data reduction based on the JPFITS FITS-file interface. It can view, manipulate, and save FITS primary image data and image extensions, view and manipulate FITS image headers, and view FITS Bintable extensions. The code enables batch processing, viewing, and saving of FITS images and searching FITS files on disk. CCDLAB also provides general image reduction techniques, source detection and characterization, and can create World Coordinate Solutions automatically or manually for FITS images.

[ascl:2206.021]
PyCASSO2: Stellar population and emission line fits in integral field spectra

de Amorim, André Luiz; Vale Asari, Natalia; Cid Fernandes, Roberto; García-Benito, Rubén; Werle, Ariel

PyCASSO runs the STARLIGHT code (ascl:1108.006) in integral field spectra (IFS). Cubes from various instruments are supported, including PMAS/PPAK (CALIFA), MaNGA, GMOS and MUSE. Emission lines can be measured using DOBBY, which is included in the package. The package also includes tools for IFS cubes analysis and plotting.

[ascl:2206.022]
RealSim-IFS: Realistic synthetic integral field spectrscopy of galaxies from numerical simulations

RealSim-IFS generates survey-realistic integral-field spectroscopy (IFS) observations of galaxies from numerical simulations of galaxy formation. The tool is designed primarily to emulate current and experimental observing strategies for IFS galaxy surveys in astronomy, and can reproduce both the flux and variance propagation of real galaxy spectra to cubes. RealSim-IFS has built-in functions supporting SAMI and MaNGA IFU footprints, but supports any fiber-based IFU design, in general.

[ascl:2206.023]
pyPipe3D: Spectroscopy analysis pipeline

Lacerda, Eduardo A. D.; Sánchez, S. F.; Mejía-Narváez, A.; Camps-Fariña, A.; Espinosa-Ponce, C.; Barrera-Ballesteros, J. K.; Ibarra-Medel, H.; Lugo-Aranda, A. Z.

The spectroscopy analysis pipeline pyPipe3D produces coherent and easy to distribute and compare parameters of stellar populations and ionized gas; it is suited in particular for data from the most recent optical IFS surveys. The pipeline is build using pyFIT3D, which is the main spectral fitting module included in this package.

[ascl:2206.024]
Wavetrack: Arbitrary time-evolving solar object recognition and tracking

Wavetrack recognizes and tracks CME shock waves, filaments, and other solar objects. The code creates base images by averaging а series of images a few minutes prior to the start of the eruption and constructs base difference images by subtracting base images from the current raw image of the sequence. This enhances the change in intensity caused by coronal bright fronts, omits static details, and reduces noise. Wavetrack then chooses an appropriate intensity interval and decomposes the base difference or running difference image with an A-Trous wavelet transform, where each wavelet coefficient is obtained by convolving the image array with a corresponding iteration of the wavelet kernel. When the maximum value of the wavelet coefficients for a connected set of pixels satisfies certain conditions, this region is considered as a structure on the respective wavelet coefficient. Separate stand-alone object masks are obtained with a clustering algorithm and objects are renumbered according to the number of the quadrant they belong at each iteration.

[ascl:2206.025]
CuspCore: Core formation in dark matter haloes and ultra-diffuse galaxies by outflow episodes

Freundlich, Jonathan; Jiang, Fangzhou; Dekel, Avishai; Cornuault, Nicolas; Ginzburg, Omry; Koskas, Rémy; Lapiner, Sharon; Dutton, Aaron; Macciò, Andrea V.

CuspCore describes the formation of flat cores in dark matter haloes and ultra-diffuse galaxies from feedback-driven outflow episodes. The halo response is divided into an instantaneous change of potential at constant velocities followed by an energy-conserving relaxation. The core assumption of the model is that the total energy E=U+K is conserved for each shell enclosing a given dark matter mass, which is treated in the code as a least-square minimization of the difference between the final and the initial energy of each shell.

[ascl:2206.026]
ShapePipe: Galaxy shape measurement pipeline

Farrens, S.; Guinot, A.; Kilbinger, M.; Liaudat, T.; Baumont, L.; Jimenez, X.; Peel, A.; Pujol, A.; Schmitz, M.; Starck, J. -L.; Vitorelli, A. Z.

ShapePipe processes single-exposure images and stacked images. Input images have to be calibrated beforehand for astrometry and photometry. The code can handle different image and file types, such as single-exposure mosaic, single-exposure single-CCD, stacked images, database catalog files, and PSF files, some of which are created by the pipeline during the analysis, among others. The end product of ShapePipe is a final catalog containing information for each galaxy, including its shape parameters and the ellipticity components :math:e_1 and :math:e_2. This catalog also contains shapes of artificially sheared images. This information is used in post-processing to compute calibrated shear estimates via metacalibration.

[ascl:2206.027]
DustFilaments: Paint filaments to produce a thermal dust full sky map at mm frequencies

DustFilaments paints filaments in the Celestial Sphere to generate a full sky map of the Thermal Dust emission at millimeter frequencies by integrating a population of 3D filaments. The code requires a magnetic field cube, which can be calculated separately or by DustFilaments. With the magnetic field cube as input, the package creates a random filament population with a given seed, and then paints a filament into a healpix map provided as input; the healpix map is updated in place.

[ascl:2206.028]
Spritz: General relativistic magnetohydrodynamic code

The Spritz code is a fully general relativistic magnetohydrodynamic code based on the Einstein Toolkit (ascl:1102.014). The code solves the GRMHD equations in 3D Cartesian coordinates and on a dynamical spacetime. Spritz supports tabulated equations of state, takes finite temperature effects into account and allows for the inclusion of neutrino radiation.

[submitted]
Compact Binary Chebyshev Polynomial Representation Ephemeris Kernel

The software used to transform the tabular USNO/AE98 asteroid ephemerides into a Chebyshev polynomial representations, and evaluate them at an arbitrary time is available. The USNO/AE98 consisted of the ephemerides of fifteen of the largest asteroids, and were used in The Astronomical Almanac from 2000 through 2015. These ephemerides are outdated and no longer available, but the software used to store and evaluate them is still available and provides a robust method for storing compact ephemerides of solar system bodies.

The object of the software is to provide a compact binary representation of solar system bodies with eccentric orbits, which can produce the body's position and velocity at an arbitrary instant within the ephemeris' time span. It uses a modification of the Newhall (1989) algorithm to achieve this objective. The Newhall algorithm is used to store both the Jet Propulsion Laboratory DE and the Institut de mécanique céleste et de calcul des éphémérides INPOP high accuracy planetary ephemerides. The Newhall algorithm breaks an ephemeris into a number time contiguous segments, and each segment is stored as a set of Chebyshev polynomial coefficients. The length of the time segments and the maximum degree Chebyshev polynomial coefficient is fixed for each body. This works well for bodies with small eccentricities, but it becomes inefficient for a body in a highly eccentric orbit. The time segment length and maximum order Chebyshev polynomial coefficient must be chosen to accommodate the strong curvature and fast motion near pericenter, while the body spends most of its time either moving slowly near apocenter or in the lower curvature mid-anomaly portions of its orbit. The solution is to vary the time segment length and maximum degree Chebyshev polynomial coefficient with the body's position. The portion of the software that converts tabular ephemerides into a Chebyshev polynomial representation (CPR) performs this compaction automatically, and the portion that evaluates that representation requires only a modest increase in the evaluation time.

The software also allows the user to choose the required tolerance of the CPR. Thus, if less accuracy is required a more compact, somewhat quicker to evaluate CPR can be manufactured and evaluated. Numerical tests show that a fractional precision of 4e-16 may be achieved, only a factor of 4 greater than the 1e-16 precision of a 64-bit IEEE (2019) compliant floating point number.

The software is written in C and designed to work with the C edition of the Naval Observatory Vector Astrometry Software (NOVAS). The programs may be used to convert tabular ephemerides of other solar system bodies as well. The included READ.ME file provides the details of the software and how to use it.

REFERENCES

IEEE Computer Society 2019, IEEE Standard for Floating-Point Arithmetic. IEEE STD 754-2019, IEEE, pp. 1–84

Newhall, X X 1989, 'Numerical Representation of Planetary Ephemerides,' Celest. Mech., 45, 305 - 310

[submitted]
CosmicEmu: High Precision Emulator for the Nonlinear Matter Power Spectrum

Moran, Kelly R.; Heitmann, Katrin; Lawrence, Earl; Habib, Salman; Bingham, Derek; Upadhye, Amol; Kwan, Juliana; Higdon, David; Payne, Richard

Modern cosmological surveys are delivering datasets characterized by unprecedented quality and statistical completeness. In order to maximally extract cosmological information from these observations, matching theoretical predictions are needed. In the nonlinear regime of structure formation, cosmological simulations are the primary means of obtaining the required information but the computational cost of sufficiently resolved large-volume simulations makes it prohibitive to run very large ensembles. Nevertheless, precision emulators built on a tractable number of high-quality simulations can be used to build very fast prediction schemes to enable a variety of cosmological inference studies. The "Mira-Titan Universe" simulation suite covers the standard six cosmological parameters and, in addition, includes massive neutrinos and a dynamical dark energy equation of state. It is based on 111 cosmological simulations, each covering a (2.1Gpc)^3 volume and evolving 3200^3 particles, and augments these higher-resolution simulations with an additional set of 1776 lower-resolution simulations and TimeRG perturbation theory results to cover scales straddling the linear to mildly nonlinear regimes. The emulator built on this suite, the CosmicEmu, provides predictions at the two to three percent level of accuracy over a wide range of cosmological parameters. Presented in: https://arxiv.org/abs/2207.12345.

[ascl:2207.001]
MULTIGRIS: Multicomponent probabilistic grid search

MULTIGRIS (also called mgris) uses the sequential Monte Carlo method in PyMC (ascl:1506.005) to extract the posterior distributions of primary grid parameters and predict unobserved parameters/observables. The code accepts either a discrete number of components and/or continuous (e.g., power-law, normal) distributions for any given parameter. MULTIGRIS, written in Python, infers the posterior probability functions of parameters in a multidimensional potentially incomplete grid with some observational tracers defined for each parameter set. Observed values and their potentially asymmetric uncertainties are used to calculate a likelihood which, together with predefined or custom priors, produces the posterior distributions. Linear combinations of parameter sets may be used with inferred mixing weights and nearest neighbor or linear interpolation may be used to sample the parameter space.

[ascl:2207.002]
pynucastro: Python interfaces to the nuclear reaction rate databases

pynucastro interfaces to the nuclear reaction rate databases, including the JINA Reaclib nuclear reactions database. This set of Python interfaces enables interactive exploration of rates and collection of rates (networks) in Jupyter notebooks and easy creation of the righthand side routines for reaction network integration (the ODEs) for use in simulation codes.

[ascl:2207.003]
MeSsI: MErging SystemS Identification

MeSsI performs an automatic classification between merging and relaxed clusters. This method was calibrated using mock catalogues constructed from the millennium simulation, and performs the classification using some machine learning techniques, namely random forest for classification and mixture of gaussians for the substructure identification.

[ascl:2207.004]
cosmic-kite: Auto-encoding the Cosmic Microwave Background

Cosmic-kite performs a fast estimation of the TT Cosmic Microwave Background (CMB) power spectra corresponding to a set of cosmological parameters; it can also estimate the maximum-likelihood cosmological parameters from a power spectra. This software is an auto-encoder that was trained and calibrated using power spectra from random cosmologies computed with the CAMB code (ascl:1102.026).

[ascl:2207.005]
echelle: Dynamic echelle diagrams for asteroseismology

Echelle diagrams are used mainly in asteroseismology, where they function as a diagnostic tool for estimating Δν, the separation between modes of the same degree ℓ; the amplitude spectrum of a star is stacked in equal slices of Δν, the large separation. The echelle Python code creates and manipulates echelle diagrams. The code provides the ability to dynamically change Δν for rapid identification of the correct value. echelle features performance optimized dynamic echelle diagrams and multiple backends for supporting Jupyter or terminal usage.

[ascl:2207.006]
MultiModes: Efficiently analyze pulsating stars

Pamos Ortega, David; García Hernández, Antonio; Suárez, Juan Carlos; Pascual Granado, Javier; Barceló Forteza, Sebastià; Rodón, José Ramón

MultiModes extracts the most significant frequencies of a sample of classical pulsating stars. The code takes a directory with light curves and initial parameters as input. For every light curve, the code calculates the frequencies spectrum, or periodogram, with the Fast Lomb Scargle algorithm, extracts the higher amplitude peak, and evaluates whether it is a real signal or noise. It fits frequency, amplitude, and phase through non-linear optimization, using a multisine function. This function is redefined with the new calculated parameters. MultiModes then does a simultaneous fit of a number of peaks (20 by default), subtracts them from the original signal, and goes back to the beginning of the loop with the residual, repeating the same process until the stop criterion is reached. After that, the code can filter suspicious spurious frequencies, those of low amplitude below the Rayleigh resolution, and possible combined frequencies.

[ascl:2207.007]
Pyriod: Period detection and fitting routines

Pyriod provides basic period detection and fitting routines for astronomical time series. Written in Python and designed to be run interactively in a Jupyter notebook, it displays and allows the user to interact with time series data, fit frequency solutions, and save figures from the toolbar. It can display original or residuals time series, fold the time series on some frequency, add selected peaks from the periodogram to the model, and refine the fit by computing a least-squared fit of the model using Lmfit (ascl:1606.014).

[ascl:2207.008]
TESS_PRF: Display the TESS pixel response function

TESS_PRF displays the TESS pixel response function (PRF) at any location on the detector. The package is primarily for estimating how the light from a point source is distributed given its position in a TESS Target Pixel File (TPF) or TESScut postage stamp. By default, it accesses the relevant PRF files on MAST, but can also reference files on a local directory. TESS_PRF assumes the PRF doesn't change considerably within a small TPF. The PRF model can be positioned by passing the relative row and column location within the TPF to the "resample" method. The pixel locations follow WCS convention, that an integer value corresponds to the center of a pixel.

[ascl:2207.009]
SolAster: 'Sun-as-a-star' radial velocity variations

Ervin, Tamar; Halverson, Samuel; Burrows, Abigail; Murphy, Nei; Roy, Arpita; Haywood, Raphaelle D.; Rescigno, Federica; Bender, Chad F.; Lin, Andrea S. J.; Burt, Jennifer; Mahadevan, Suvrath

SolAster provides querying, analysis, and calculation methods to independently derive 'sun-as-a-star' RV variations using SDO/HMI data for any time span since SDO has begun observing. Scaling factors are provided in order to calculate RVs comparable to magnitudes measured by ground-based spectrographs (HARPS-N and NEID). In addition, there are routines to calculate magnetic observables to compare with RV variations and determine what is driving Solar activity.

Would you like to view a random code?