Results 3401-3500 of 3615 (3521 ASCL, 94 submitted)
CosmosCanvas creates perception-based color maps for different astrophysical properties such as spectral index and velocity fields. Three tutorials demonstrate how to use python code to exploit and adjust the boundaries in these divergent colour schemes. Intended to work with human physiology, each tutorial offers at least one default scheme that is monotonic in value both as a redundancy for supporting data information and an aid for colour blind viewers. This library relies on Gilles Ferrand's colourspace library.
LoSoTo (LOFAR Solution Tool) performs a variety of operations on H5parm data, which is based on the HDF5 format; it isolates direction independent systematic effects and can therefore be transferred to the target field. Subsets of data can be selected for each operation using lists of axes values, regular expressions, or intervals. The LoSoTo package stores solutions in arrays organized in a hierarchical fashion; this provides flexibility and preserves performance. The code can, for example, extract Faraday rotation from RR/LL phase solutions or a rotation matrix, clip solutions around the median, and calculate the ionospheric structure function. LoSoTo includes an outlier flagging procedure, normalizes solutions to a given value, and offers an advanced plotting routine, and many other operations.
deal.II computes solutions to partial differential equations (PDEs) using adaptive finite elements. The code provides an interface for processing PDEs accessible to both laptops and supercomputers, and has been used to investigate the local and global waveform effects of gravitational waves by numerical simulation. deal.II supports massively parallel computing of very large linear systems of equations and provides access to triangulation of various geometries of the simulation domain.
DARC (Dirac Atomic R-matrix Codes) enables the study of continuum processes for a general atomic system. The suite of programs calculate electron-atom or electron-ion collision cross-sections. In addition, the programs include code for bound-state and photoionization calculations.
harmonic learns an approximate harmonic mean estimator (referred to as a "learnt harmonic mean estimator") from posterior distribution samples to compute the marginal likelihood required for Bayesian model selection. Using a large number of independent Markov chain Monte Carlo (MCMC) chains from another package such as emcee (ascl:1303.002), harmonic uses importance sampling to learn a new target distribution in order to optimize an approximate harmonic estimator while minimizing its variance.
The Feed Forward Neural Network SYSNet models the relationship between the imaging maps, such as stellar density and the observed galaxy density field, in order to mitigate the systematic effects and to make a robust galaxy clustering measurements. The cost function is Mean Squared Error and a L2 regularization term, and the optimization algorithm is Adaptive Moment (ADAM).
Ostrich emulates surrogate models for complex and expensive functions using Principal Component Analysis (PCA) to decompose a signal, then interpolate the PCA weights over the parameters θ using a Gaussian Process interpolator. The code is trained on samples from the expensive functions, recreating and interpolating between those training samples with reduced computational cost, and recalculating for each use.
baryon-sweep produces a robust outlier rejection while simultaneously preserving the signal of the science target. The code works as a standalone solution or as a supplement to the current pipeline software. baryon-sweep creates the 2D pixel mask and mask layers, processes the sky (non-science target) spaxels, and creates a post-processed cube ready for use.
SolarKAT mitigates solar interference in MeerKAT data and recovers the visibilities rather than discarding them; this solar imaging pipeline takes 1GC calibrated data in Measurement Set format as input. Written in Python, the pipeline employs solar tracking, subtraction, and peeling techniques to enhance data quality by significantly reducing solar radio interference. This is achieved while preserving the flux measurements in the main field. SolarKAT is versatile and can be applied to general radio astronomy observations and solar radio astronomy; additionally, generated solar images can be used for weather forecasting. SolarKAT is deployed in Stimela (ascl:2305.007). It is based on existing radio astronomy software, including CASA (ascl:1107.013), breizorro (ascl:2305.009), WSclean (ascl:1408.023), Quartical (ascl:2305.006), and Astropy (ascl:1304.002).
LoRD (Locate Reconnection Distribution) identifies the locations and structures of 3D magnetic reconnection within discrete magnetic field data. The toolkit contains three main functions; the first, ARD (Analyze Reconnection Distribution) locates the grids undergoing reconnection without null points and also recognizes the local configurations of reconnection sites. ANP (Analyze Null Points) locates and classifies the 3D null points, and APNP (Analyze Projected Null Points) analyzes the 2D neutral points projected on a plane near a cell. LoRD is written in Matlab and the toolkit contains demo scripts.
maskfill inward extrapolates edge pixels just outside masked regions, using iterative median filtering and the full information contained in the edge pixels. This provides seamless transitions between masked pixels and good pixels, and allows high fidelity reconstruction of gaps in continuous narrow features. An image and a mask the only required inputs.
CRR (Convex Ridge Regularizer) takes the gradient of regularizers that are the sum of convex-ridge functions and parameterizes them using a neural network that has a single hidden layer with increasing and learnable activation functions. The neural network is trained within a few minutes as a multistep Gaussian denoiser, and offers improvements for denoising and image reconstruction over other methods with similar reliability.
QuantifAI reconstructs radio interferometric images using scalable Bayesian uncertainty quantification relying on data-driven (learned) priors. It relies on the convex accelerated optimization algorithms in CRR (ascl:2401.016) and is built on top of PyTorch. QuantifAI also includes MCMC algorithms for posterior sampling.
tidalspin uses a Bayesian approach to infer posterior distributions of a black hole's parameters (mass and spin) in an observed tidal disruption event, given a prior estimate of the black hole’s mass (e.g., from a galactic scaling relationship, or the tidal disruption event’s observed properties). These posterior distributions will only utilize the properties of tidal forces in their inference. tidalspin can be applied to the population of tidal disruption events already discovered.
StructureFunction determines the X-ray Structure Function of a population of Active Galactic Nuclei (AGN) for which two epoch X-ray observations are available and are separated by rest frame time interval. The calculation of the X-ray structure function is Bayesian. The sampling of the likelihood uses Stan (ascl:1801.003) for statistical modeling and high-performance statistical computation.
escatter.py performs Monte Carlo simulations of electron scattering events. The code was developed to better understand the emission lines from the interacting supernova SN 2021adxl, specifically the blue excess seen in the Hα 6563A emission line. escatter follows a photon that was formed in a thin interface between the supernova ejecta and surrounding material as it travels radially outwards through the dense material, scattering electrons outwards until it reaches an optically thin region, and plots a histogram of the emergent photons.
NMMA probes nuclear physics and cosmology with multimessenger analysis. This fully featured, Bayesian multi-messenger pipeline targets joint analyses of gravitational-wave and electromagnetic data (focusing on the optical). Using bilby (ascl:1901.011) as the back-end, the software uses a variety of samplers to sampling these data sets. NMMA uses chiral effective field theory based neutron star equation of states when performing inference, and is also capable of estimating the Hubble Constant.
Rfits reads and writes FITS images, tables, and headers. Written in R, Rfits works with all types of compressed images, and both ASCII and binary tables. It uses CFITSIO (ascl:1010.001) for all low level FITS IO, so in general should be as fast as other CFITSIO-based software. For images, Rfits offers fully featured memory mapping and on-the-fly subsetting (by pixel and coordinate) and sparse pixel sampling, allowing for efficient inspection of very large (larger than memory) images.
Rwcs offers access to all the projection and distortion systems of WCSLIB (ascl:1108.003) in R. This can be used directly for, for example, pixel lookups, or for higher level general distortion and projection.
CCBH-Numerics (previously called CCBH-PLPP) computes the probability of the existence of a single cosmologically coupled black hole (BH) with a formation mass below a specified threshold for given observational data of binary black holes (BBHs) from gravitational waves. The code uses the unbiased population of BBHs, as given by the power-law-plus-peak (PLPP) profile, as the observational input, and assumes that the detected BBHs are formed from stellar evolution, not primordial BHs. CCBH-Numerics also works with individual data from BBHs and for NSBH pairs as well.
MGPT (Modified Gravity Perturbation Theory) computes 2-point statistics for LCDM model, DGP and Hu-Sawicky f(R) gravity. Written in C, the code can be easily modified to include other models. Specifically, it computes the SPT matter power spectrum, SPT Lagrangian-biased tracers power spectrum, and the CLPT matter correlation function. MGPT also computes the CLPT Lagrangian-biased tracers correlation function and a set of Q and R functionsfrom which other statistics, as leading order bispectrum, can be constructed.
polarizationtools converts, analyzes, and simulates polarization data. The different python scripts (1) convert Stokes parameters into linear polarization parameters with proper treatment of the uncertainties and vice versa; (2) shift electric vector position angle (EVPA) data points in time series to account for the 180 degrees ambiguity; (3) identify rotations of the EVPA e.g. in blazar polarization monitoring data according to various rotation definitions; and (4) simulate polarization time series as a random walk in the Stokes Q-U plane.
ECLIPSR fully and automatically analyzes space based light curves to find eclipsing binaries and provide some first order measurements, such as the binary star period and eclipse depths. It provides a recipe to find individual eclipses using the time derivatives of the light curves, including eclipses in light curves of stars where the dominating variability is, for example, pulsations. Since the algorithm detects each eclipse individually, even light curves containing only one eclipse can (in principle) be successfully analyzed and classified. ECLIPSR can find eclipsing binaries among both pulsating and non-pulsating stars in a homogeneous and quick manner and process large amounts of light curves in reasonable amounts of time. The output includes, among other things, the individual eclipse markers, the period and time of first (primary) eclipse, and a score between 0 and 1 indicating the likelihood that the analyzed light curve is that of an eclipsing binary.
star_shadow automatically analyzes space based light curves of eclipsing binaries and provide a measurement of eccentricity, among other parameters. It measures the timings of eclipses using the time derivatives of the light curves, using a model of orbital harmonics obtained from an initial iterative prewhitening of sinusoids. Since the algorithm extracts the harmonics from the rest of the sinusoidal variability eclipse timings can be measured even in the presence of other (astrophysical) signals, thus determining the orbital eccentricity automatically from the light curve along with information about the other variability present in the light curve. The output includes, but is not limited to, a sinusoid plus linear model of the light curve, the orbital period, the eccentricity, argument of periastron, and inclination.
SkyLine generates mock line-intensity maps (both in 3D and 2D) in a lightcone from a halo catalog, accounting for the evolution of clustering and astrophysical properties, and observational effects such as spectral and angular resolutions, line-interlopers, and galactic foregrounds. Using a given astrophysical model for the luminosity of each line, the code paints the signal for each emitter and generates the map, adding coherently all contributions of interest. In addition, SkyLine can generate maps with the distribution of Luminous Red Galaxies and Emitting Line Galaxies.
2cosmos is a modification of Monte Python (ascl:1307.002) and allows the user to write likelihood modules that can request two independent instances of CLASS (ascl:1106.020) and separate dictionaries and structures for all cosmological and nuisance parameters. The intention is to be able to evaluate two independent cosmological calculations and their respective parameters within the same likelihood. This is useful for evaluating a likelihood using correlated datasets (e.g. mutually exclusive subsets of the same dataset for which one wants to take into account all correlations between the subsets).
Pynkowski computes Minkowski Functionals and other higher order statistics of input fields, as well as their expected values for different kinds of fields. This package supports Minkowski functionals, and maxima and minima distributions. Supported input formats include scalar HEALPix maps such as those used by healpy (ascl:2008.022) and polarization HEALPix maps in the SO(3) formalism. Pynkowski also supports various theoretical fields, including Gaussian (e.g., CMB Temperature or the initial density field), Chi squared (e.g., CMB polarization intensity), and spin 2 maps in the SO(3) formalism.
DistClassiPy uses different distance metrics to classify objects such as light curves. It provides state-of-the-art performance for time-domain astronomy, and offers lower computational requirements and improved interpretability over traditional methods such as Random Forests, making it suitable for large datasets. DistClassiPy allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, which enhances its performance and improves classification interpretability.
kinematic_scaleheight uses MCMC methods to kinematically estimate the vertical distribution of clouds in the Galactic plane, including the least squares analysis of Crovisier (1978), an updated least squares analysis using a modern Galactic rotation model, and a Bayesian model sampled via MCMC as described in Wenger et al. (2024).
BTSbot automates real-time identification of bright extragalactic transients in Zwicky Transient Facility (ZTF) data. A multi-modal convolutional neural network, BTSbot provides a bright transient score to individual ZTF detections using their image data and 25 extracted features. The package eliminates the need for daily visual inspection of new transients by automatically identifying and requesting spectroscopic follow-up observations of new bright transient candidates. BTSbot recovers all bright transients in our test split and performs on par with human experts in terms of identification speed (on average, ∼1 hour quicker than scanners).
Poke (pronounced /poʊˈkeɪ/ or po-kay) uses commercial ray tracing APIs and open-source physical optics engines to simultaneously model scalar wavefront error, diffraction, and polarization to bridge the gap between ray trace models and diffraction models. It operates by storing ray data from a commercial ray tracing engine into a Python object, from which physical optics calculations can be made. Poke provides two propagation physics modules, Gaussian Beamlet Decomposition and Polarization Ray Tracing, that add to the utility of existing scalar diffraction models. Gaussian Beamlet Decomposition is a ray-based approach to diffraction modeling that integrates physical optics models with ray trace models to directly capture the influence of ray aberrations in diffraction simulations. Polarization Ray Tracing is a ray-based method of vector field propagation that can diagnose the polarization aberrations in optical systems.
fkpt computes the 1-loop redshift space power spectrum for tracers using perturbation theory for LCDM and Modified Gravity theories using "fk"-Kernels. Though implemented for the Hu-Sawicky f(R) modified gravity model, it is straightforward to use it for other models.
The MINDS hybrid pipeline is based on the JWST pipeline and routines from the VIP package (ascl:1603.003) for the reduction of JWST MIRI-MRS data. The pipeline compensates for some of the known weaknesses of the official JWST pipeline to improve the quality of spectrum extracted from MIRI-MRS data. This is done by leveraging the capabilities of VIP, another large data reduction package used in the field of high-contrast imaging.
The front end of the pipeline is a highly automated Jupyter notebook. Parameters are typically set in one cell at the beginning of the notebook, and the rest of the notebook can be run without any further modification. The Jupyter notebook format provides flexibility, enhanced visibility of intermediate and final results, more straightforward troubleshooting, and the possibility to easily incorporate additional codes by the user to further analyze or exploit their results.
s4cmb (Systematics For Cosmic Microwave Background) studies the impact of instrumental systematic effects on measurements of CMB experiments based on bolometric detector technology. s4cmb provides a unified framework to simulate raw data streams in the time domain (TODs) acquired by CMB experiments scanning the sky, and to inject in these realistic instrumental systematics effect.
pycorr wraps two-point counter engines such as Corrfunc (ascl:1703.003) to estimate the correlation function. It supports theta (angular), s, s-mu, rp-pi binning schemes, analytical two-point counts with periodic boundary conditions, and inverse bitwise weights (in any integer format) and (angular) upweighting. It also provides MPI parallelization and jackknife estimate of the correlation function covariance matrix.
FitCov estimates the covariance of two-point correlation functions in a way that requires fewer mocks than the standard mock-based covariance. Rather than using an analytically fixed correction to some terms that enter the jackknife covariance matrix, the code fits the correction to a mock-based covariance obtained from a small number of mocks. The fitted jackknife covariance remains unbiased, an improvement over other methods, performs well both in terms of precision (unbiased constraints) and accuracy (similar uncertainties), and requires significant less computational power. In addition, FitCov can be easily implemented on top of the standard jackknife covariance computation.
LtU-ILI (Learning the Universe Implicit Likelihood Inference) performs machine learning parameter inference. Given labeled training data or a stochastic simulator, the LtU-ILI piepline automatically trains state-of-the-art neural networks to learn the data-parameter relationship and produces robust, well-calibrated posterior inference. The package comes with a wide range of customizable complexity, including posterior-, likelihood-, and ratio-estimation methods for ILI, including sequential learning analogs, and various neural density estimators, including mixture density networks, conditional normalizing flows, and ResNet-like ratio classifiers. It offers fully-customizable, exotic embedding networks, including CNNs and Graph Neural Networks, and a unified interface for multiple ILI backends such as sbi, pydelfi, and lampe. LtU-ILI also handles multiple marginal and multivariate posterior coverage metrics, and offers Jupyter and command-line interfaces and a parallelizable configuration framework for efficient hyperparameter tuning and production runs.
Pylians3 (Python3 libraries for the analysis of numerical simulations) provides a Python 3 version of Pylians (ascl:1811.008), which analyzes numerical simulations (both N-body and hydrodynamic); parts of the codebase are also written in cython and C. It computes density fields, power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians3 also applies HI+H2 corrections to the output of hydrodynamic simulations, make 21cm maps, computes DLAs column density distribution functions, and can plot density fields and make movies.
URecon reconstructs the initial conditions of N-body simulations from late time (e.g., z=0) density fields. This simple UNET architecture is implemented in TensorFlow and requires Pylians3 (ascl:2403.012) for measuring power spectrum of density fields. The package includes weights trained on Quijote fiducial cosmology simulations.
OneLoopBispectrum computes the one-loop bispectrum of galaxies in redshift space. It computes and simplifies the bispectrum kernels using Mathematica; this is cosmology-independent. The code also computes the full and flattened bispectrum templates, given the pre-computed integration kernels. OneLoopBispectrum uses Mathematica to read in and combine the bispectrum templates, and Python to interpolate and extract the one-loop bispectrum.
CLASS-PT modifies the CLASS (ascl:1106.020) code to compute the non-linear power spectra of dark matter and biased tracers in one-loop cosmological perturbation theory, for both Gaussian and non-Gaussian initial conditions. CLASS-PT can be interfaced with the MCMC sampler MontePython (ascl:1805.027) using the (new and improved) custom-built likelihoods found here.
The DensityFieldTools toolset manipulates density fields and measures power spectra and bispectra using a very simple interface. After loading a density field, it computes the power spectrum and the bispectrum for a desired binning. The bispectrum estimator also automatically computes the power spectrum for the chosen binning, to facilitate, for example, shot-noise subtraction. DensityFieldTools also provides a quick way to measure (cross-)power spectra directly from density fields.
Obsplanning is a suite of tools to help plan astronomical observations from ground-based observatories, for traditional single-site as well as multi-station (VLBI) observing. Conveniently determine observability of objects in the sky from your observatory, and produce plots to help you prepare for your observations over the course of a session. Celestial source coordinates (including solar system objects) can be queried or created, and transformed. Calibrator or reference sources can be selected by proximity, and slew order can be optimized to save valuable telescope time. Plots and visualizations can be easily made to chart source elevation and transits, source proximity to the Sun and Moon, concurrent 'up time' of sources at multiple sites (for VLBI or tandem observations), 'dark time' at a telescope site for a given year, finder plots made from real images (with options to query online databases), and more.
cbeam models the propagation of guided light through slowly-varying few-mode waveguides using the coupled-mode theory (CMT). When compared with more general numerical methods for waveguide simulation, such as the finite-differences beam propagation method (FD-BPM), numerical implementations of the CMT can be much more computationally efficient. Written in Python and Julia, the package provides a Pythonic class structure to define waveguides, with simple classes for directional couplers and photonic lanterns already provided. cbeam also doubles as a finite-element eigenmode solver.
PIPE (PSF Imagette Photometric Extraction) extracts PSF (point-spread function) photometry from data acquired by the space telescope CHEOPS (CHaracterisation of ExOPlanetS). Advantages of PSF photometry over standard aperture photometry include reduced sensitivity to contaminants such as background stars, cosmic ray hits, and hot/bad pixels. For CHEOPS, an additional advantage is that photometry can be extracted from an imagette, a small window around the target that is downlinked at a shorter cadence than the larger-sized subarray used for aperture photometry. These advantages make PIPE particularly well suited for targets brighter or fainter than the nominal G = 7-11 mag range of CHEOPS, i.e., where short-cadence imagettes are available (bright end) or when contamination becomes a problem (faint end). Within the nominal range, PIPE usually offers no advantage over the standard aperture photometry.
KCWIKit extends the official KCWI DRP (ascl:2301.019) with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.
TAT-pulsar (Timing Analysis Toolkit for Pulsars) analyzes, processes, and visualizes pulsar data, thus handling the scientific intricacies of pulsar timing. By leveraging observational data from pulsars, along with the associated physical processes and statistical characteristics, the package integrates a suite of Python-based tools and data analysis scripts specifically developed for both isolated pulsars and binary systems. This enables swift analysis and the detailed presentation of timing properties in the high-energy pulsar field. Developed and implemented completely independently from other pulsar timing software such as Stingray (ascl:1608.001) and PINT (ascl:1902.007), TAT-pulsar serves as a valuable cross-checking and supplementary tool for data analysis.
GalMOSS performs two-dimensional fitting of galaxy profiles. This Python-based, Torch-powered tool seamlessly enables GPU parallelization and meets the high computational demands of large-scale galaxy surveys. It incorporates widely used profiles such as the Sérsic, Exponential disk, Ferrer, King, Gaussian, and Moffat profiles, and allows for the easy integration of more complex models. Tested on over 8,000 galaxies from the Sloan Digital Sky Survey (SDSS) g-band with a single NVIDIA A100 GPU, GalMOSS completed classical Sérsic profile fitting in about 10 minutes. Benchmark tests show that GalMOSS achieves computational speeds that are significantly faster than those of default implementations.
PolyBin3D estimates the binned power spectrum and bispectrum for 3D fields such as the distributions of matter and galaxies. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. In the second case, the computation of a Fisher matrix is required; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin3D supports GPU acceleration using JAX. It is a sister code to PolyBin (ascl:2307.020), which computes the polyspectra of data on the two-sphere, and is a modern reimplementation of the former Spectra-Without-Windows (ascl:2108.011) code.
WignerFamilies generates families of Wigner 3j and 6j symbols by recurrence relation. These exact methods are orders of magnitude more efficient than strategies such as prime factorization for problems which require every non-trivial symbol in a family, and are very useful for large quantum numbers. WignerFamilies is thread-safe and very fast, beating the standard Fortran routine DRC3JJ from SLATEC by a factor of 2-4.
LensIt enables CMB lensing and CMB delensing using the flat-sky approximation. The package can find the maximum posterior estimation of CMB lensing deflection maps from temperature and/or polarization maps and perform Wiener filtering of masked CMB data and allow for inhomogenous noise, including lensing deflections, using a multigrid preconditioner. It contains fast and accurate simulation libraries for lensed CMB skies, and standard quadratic estimator lensing reconstruction tools. LensIt also includes CMB internal delensing tools, including internal delensing biases calculation for temperature and/or polarization maps.
The superABC sampling method obtains cosmological constraints from supernova light curves using Approximate Bayesian Computation (ABC) without any likelihood assumptions. It provides an interface to two forward model simulations, SNCosmo (ascl:1611.017) and SNANA (ascl:1010.027), for supernova cosmology.
Panphasia computes a very large realization of a Gaussian white noise field. The field has a hierarchical structure based on an octree geometry with 50 octree levels fully populated. The code sets up Gaussian initial conditions for cosmological simulations and resimulations of structure formation. Panphasia provides an easy way to publish the linear phases used to set up cosmological simulation initial conditions; publishing phases enriches the literature and makes it easier to reproduce and extend published simulation work.
BayeSN performs hierarchical Bayesian SED modeling of type Ia supernova light curves. This probabilistic optical-NIR SED model analyzes the population distribution of physical properties as well as cosmology-independent distance estimation for individual SNe. BayeSN is built with NumPyro and Jax (ascl:2111.002) and provides support for GPU acceleration.
EffectiveHalos provides models of the real-space matter power spectrum, based on a combination of the Halo Model and Effective Field Theory, which are 1% accurate up to k = 1 h/Mpc, across a range of cosmologies, including those with massive neutrinos. It can additionally compute accurate halo count covariances (including a model of halo exclusion), both alone and in combination with the matter power spectrum.
Meanoffset performs astronomical image alignment. The code uses the means of the rows and columns of an original image for alignment and finds the optimal offset corresponding to the maximum similarity by comparing different offsets between images. The similarity is evaluated by the standard deviation of the quotient divided by the means. The code is fast and robust.
astroNN creates neural networks for deep learning using Keras for model and training prototyping while taking advantage of Tensorflow's flexibility. It contains tools for use with APOGEE, Gaia and LAMOST data, though is primarily designed to apply neural nets on APOGEE spectra analysis and predict luminosity from spectra using data from Gaia parallax with reasonable uncertainty from Bayesian Neural Net. astroNN can handle 2D and 2D colored images, and the package contains custom loss functions and layers compatible with Tensorflow or Keras with Tensorflow backend to deal with incomplete labels. The code contains demo for implementing Bayesian Neural Net with Dropout Variational Inference for reasonable uncertainty estimation and other neural nets.
EBWeyl computes the electric and magnetic parts of the Weyl tensor, Eαβ and Bαβ, using a 3+1 slicing formulation. The module provides a Finite Differencing class with 4th (default) and 6th order backward, centered, and forward schemes. Periodic boundary conditions are used by default; otherwise, a combination of the 3 schemes is available. It also includes a Weyl class that computes for a given metric the variables of the 3+1 formalism, the spatial Christoffel symbols, spatial Ricci tensor, electric and magnetic parts of the Weyl tensor projected along the normal to the hypersurface and fluid flow, the Weyl scalars and invariant scalars. EBWeyl can also compute the determinant and inverse of a 3x3 or 4x4 matrice in every position of a data box.
The Machine Learning Telescope Pointing Correction code trains and tests machine learning models for correcting telescope pointing. Using historical APEX data from 2022, including pointing corrections, and other data such as weather conditions, position and rotation of the secondary mirror, pointing offsets observed during pointing scans, and the position of the sun, among other data, the code treats the data in two different ways to test which factors are the most likely to account for pointing errors.
pyilc implements the needlet internal linear combination (NILC) algorithm for CMB component separation in pure Python; it also implements harmonic-space ILC. The code can also perform Cross-ILC, where the covariance matrices are computed only from independent splits of the maps. In addition, pyilc includes an inpainting code, diffusive_inpaint, that diffusively inpaints a masked region with the mean of the unmasked neighboring pixels.
GPUniverse models quantum fields in finite dimensional Hilbert spaces with Generalised Pauli Operators (GPOs) and overlapping degrees of freedom. In addition, the package can simulate sets of qubits that are only quasi independent (i.e., the Pauli algebras of different qubits have small, but non-zero anti-commutator), which is useful for validating analytical results for holographic versions of the Weyl field.
PySSED (Python Stellar Spectral Energy Distributions) downloads and extracts data on multi-wavelength catalogs of astronomical objects and regions of interest and automatically proceses photometry into one or more stellar SEDs. It then fits those SEDs with stellar parameters. PySSED can be run directly from the command line or as a module within a Python environment. The package offers a wide variety plots, including Hertzsprung–Russell diagrams of analyzed objects, angular separation between sources in specific catalogs, and two-dimensional offset between cross-matches.
NbodyIMRI uses N-body simulations to study Dark Matter-dressed intermediate-mass ratio inspirals (IMRI) and extreme mass ratio inspiral (EMRI) systems. The code calculates all BH-BH forces and BH-DM forces directly while neglecting DM-DM pairwise interactions. This allows the code to scale up to very large numbers of DM particles in order to study stochastic processes like dynamical friction.
cuDisc simulates the evolution of protoplanetary discs in both the radial and vertical dimensions, assuming axisymmetry. The code performs 2D dust advection-diffusion, dust coagulation/fragmentation, and radiative transfer. A 1D evolution model is also included, with the 2D gas structure calculated via vertical hydrostatic equilibrium. cuDisc requires a NVIDIA GPU.
jetsimpy creates hydrodynamic simulations of relativistic blastwaves with tabulated angular energy and Lorentz factor profiles and efficiently models Gamma-Ray Burst afterglows. It supports tabulated angular energy and tabulated angular Lorentz factor profiles. jetsimpy also supports ISM, wind, and mixed external density profile, including synthetic afterglow light curves, apparent superluminal motion, and sky map and Gaussian equivalent image sizes. Additionally, you can add your own emissivity model by defining a lambda function in a c++ source file, allowing the package to be used for more complicated models such as Synchrotron self-absorption.
mhealpy extends the functionalities of the HEALPix (ascl:1107.018) wrapper healpy (ascl:2008.022) to handle single and multi-resolution maps (a.k.a. multi-order coverage maps or MOC maps). In addition to creating and analyzes MOC maps, it supports arithmetic operations, adaptive grids, resampling of existing multi-resolution maps, and plotting, among other functions, and reads and writes to FITS, which enables sharing spatial information for multiwavelength and multimessenger analyses.
Written in Python, pAGN solves AGN disk model equations. The code is highly customizable and, with the correct inputs, provides a fully evolved AGN disk model through parametric 1D curves for key disk parameters such as temperature and density. pAGN can be used to study migration torques in AGN disks, simulations of compact object formation inside gas disks, and comparisons with new, more complex models of AGN disks.
stringgen creates emulations of cosmic string maps with statistics similar to those of a single (or small ensemble) of reference simulations. It uses wavelet phase harmonics to calculate a compressed representation of these reference simulations, which may then be used to synthesize new realizations with accurate statistical properties, e.g., 2 and 3 point correlations, skewness, kurtosis, and Minkowski functionals.
LEO-vetter automatically vets transit signals found in light curve data. Inspired by the Kepler Robovetter (ascl:2012.006), LEO-vetter computes vetting metrics to be compared to a series of pass-fail thresholds. If a signal passes all tests, it is considered a planet candidate (PC). If a signal fails at least one test, it may be either an astrophysical false positive (FP; e.g., eclipsing binary, nearby eclipsing signal) or false alarm (FA; e.g., systematic, stellar variability). Pass-fail thresholds can be changed to suit individual research purposes, and LEO-vetter produces vetting reports for manual inspection of signals. Flux-level vetting can be applied to any light curve dataset (such as Kepler, K2, and TESS), including light curves with mixes of cadences, while pixel-level vetting has been implemented for TESS.
S2FFT computes Fourier transforms on the sphere and rotation group using JAX (ascl:2111.002) or PyTorch. It leverages autodiff to provide differentiable transforms, which are also deployable on hardware accelerators (e.g., GPUs and TPUs). More specifically, S2FFT provides support for spin spherical harmonic and Wigner transforms (for both real and complex signals), with support for adjoint transformations where needed, and comes with different optimisations (precompute or not) that one may select depending on available resources and desired angular resolution L.
binary_precursor models light curves of supernova (SN) precursors powered by a pre-SN outburst accompanying accretion onto a compact object companion. Though it is only one of the possible models, it is useful for interpretations of (bright) SN precursors highly exceeding the Eddington limit of massive stars, which are observed in a fraction of SNe with dense circumstellar matter (CSM) around the progenitor. It offers a number of editable parameters, including compact object mass, progenitor mass, progenitor radii, and opacity. Initial CSM velocity can be normalized by the progenitor escape velocity (xi parameter), and the CSM mass, ionization temperature, and binary separation can also be specified.
ExoPlex is a thermodynamically self-consistent mass-radius-composition calculator. Users input a bulk molar composition and a mass or radius, and ExoPlex will calculate the resulting radius or mass. Additionally, it will produce the planet's core mass fraction, interior mineralogy and the pressure, adiabatic temperature, gravity and density profiles as a function of depth.
RhoPop identifies compositionally distinct populations of small planets (R≲2R⊕). It employs mixture models in a hierarchical framework and the dynesty (ascl:1809.013) nested sampler for parameter and evidence estimates. RhoPop includes a density-mass grid of water-rich compositions from water mass fraction (WMF) 0-1.0 and a grid of volatile-free rocky compositions over a core mass fraction (CMF) range of 0.006-0.95. Both grids were calculated using the ExoPlex mass-radius-composition calculator (ascl:2404.029).
We present a module built into the PypeIt Python package to reduce high resolution Y, J, H, K, and L band spectra from the W. M. Keck Observatory NIRSPEC spectrograph. This data reduction pipeline is capable of spectral extraction, wavelength calibration, and telluric correction of data taken before and after the 2018 detector upgrade, all in a single package. The procedure for reducing data is thoroughly documented in an expansive tutorial.
Swiftest is a software package designed to model the long-term dynamics of system of bodies in orbit around a dominant central body, such a planetary system around a star, or a satellite system around a planet. The main body of the program is written in Modern Fortran, taking advantage of the object-oriented capabilities included with Fortran 2003 and the parallel capabilities included with Fortran 2008 and Fortran 2018. Swiftest also includes a Python package that allows the user to quickly generate input, run simulations, and process output from the simulations. Swiftest uses a NetCDF output file format which makes data analysis with the Swiftest Python package a streamlined and flexible process for the user. Building off a strong legacy, including its predecessors Swifter and Swift, Swiftest takes the next step in modeling the dynamics of planetary systems by improving the performance and ease of use of software, and by introducing a new collisional fragmentation model. Currently, Swiftest includes the four main symplectic integrators included in its predecessors: WHM, RMVS, HELIO, and SyMBA. In addition, Swiftest also contains the Fraggle model for generating products of collisional fragmentation.
The SPEDAS (Space Physics Environment Data Analysis Software) framework supports multi-mission data ingestion, analysis and visualization for the Space Physics community. It standardizes the retrieval of data from distributed repositories, the scientific processing with a powerful set of legacy routines, the quick visualization with full output control and the graph creation for use in papers and presentations. SPEDAS includes a GUI for ease of use by novice users, works on multiple platforms, and though based on IDL, can be used with or without an IDL license. The framework supports plugin modules for multiple projects such as THEMIS, MMS, and WIND, and provides interfaces for software modules developed by the individual teams of those missions. A Python implementation of the framework, PySPEDAS (ascl:2405.005), is also available.
nessai performs nested sampling for Bayesian Inference and incorporates normalizing flows. It is designed for applications where the Bayesian likelihood is computationally expensive. nessai uses PyTorch and also supports the use of bilby (ascl:1901.011).
raynest, written in Python, computes Bayesian evidences and probability distributions using parallel chains.
pyADfit models accretion discs around astrophysical objects. The code provides functions to calculate physical quantities related to accretion disks and perform parameter estimation using observational data. The accretion disc model is the alpha-disc model while the parameter estimation can be performed with Nessai (ascl:2405.002), Raynest (ascl:2405.003), or CPnest (ascl:2205.021).
pySPEDAS (Python-based Space Physics Environment Data Analysis Software) supports multi-mission, multi-instrument retrieval, analysis, and visualization of heliophysics time series data. A Python implementation of SPEDAS (ascl:2405.001), it supports most of the capabilities of SPEDAS; it can load heliophysics data sets from more than 30 space-based and ground-based missions, coordinate transforms, interpolation routines, and unit conversions, and provide interactive access to numerous data sets. pySPEDAS also creates multi-mission, multi-instrument figures, includes field and wave analysis tools, and performs magnetic field modeling, among other functions.
ICPertFLRW, a Cactus code (ascl:1102.013) thorn, provides as initial conditions an FLRW metric perturbed with the comoving curvature perturbation Rc in the synchronous comoving gauge. Rc is defined as a sum of sinusoidals (20 in each x, y, and z direction) whose amplitude, wavelength, and phase shift are all parameters in param.ccl. While the metric and extrinsic curvature only have first order scalar perturbations, the energy density is computed exactly in full from the Hamiltonian constraint, hence vector and tensor perturbations are initially present at higher order. These are then passed to the CT_Dust thorn to be evolved.
GauPro fits a Gaussian process regression model to a dataset. A Gaussian process (GP) is a commonly used model in computer simulation. It assumes that the distribution of any set of points is multivariate normal. A major benefit of GP models is that they provide uncertainty estimates along with their predictions.
i-SPin simulates 3-component Schrodinger systems with and without gravity and with and without self-interactions while obeying SO(3) symmetry. The code allows the user to input desired parameters, along with initial conditions for the Schrodinger fields. Its three function modules then perform the main (drift-kick-drift) steps of the algorithm, track the fractional changes in total mass and spin in the system, and then plot results. The default plots are mass and spin density projections along with total mass and spin fractional changes.
morphen performs image analysis, multi-Sersic image fitting decomposition, and radio interferometric self-calibration, thus measuring basic image morphology and photometry. The code provides a state-of-the-art Python-based image fitting implementation based on the Sersic function. Geared, though not exclusively, toward radio astronomy, morphen's tools involve pure python, but also are integrated with CASA (ascl:1107.013) in order to work with common casatasks as well as WSClean (ascl:1408.023).
riddler automates fitting of type Ia supernovae spectral time series. The code is comprised of a series of neural networks trained to emulate radiative transfer simulations from TARDIS (ascl:1402.018). Emulated spectra are then fit to observations using nested sampling implemented in UltraNest (ascl:1611.001) to estimate the posterior distributions of model parameters and evidences.
MMLPhoto-z is a cross-modal contrastive learning approach for estimating photo-z of quasars. This method employs adversarial training and contrastive loss functions to promote the mutual conversion between multi-band photometric data features (magnitude, color) and photometric image features, while extracting modality-invariant features.
DirectSHT performs direct spherical harmonic transforms for point sets on the sphere. Given a set of points, defined by arrays of theta and phi (in radians) and weights, it provides the spherical harmonic transform coefficients alm. JAX (ascl:2111.002) can be used to speed up the computation; the code will automatically fall back to numpy if JAX is not present. The code is much faster when run on GPUs. When they are available and JAX is installed, the code automatically distributes computation and memory across them.
fitramp fits a ramp to a series of nondestructive reads and detects and rejects jumps. The software performs likelihood-based jump detection for detectors read out up-the-ramp; it uses the entire set of reads to compute likelihoods. The code compares the χ2 value of a fit with and without a jump for every possible jump location. fitramp can fit ramps with and without fitting the reset value (the pedestal), and fit and mask jumps within or between groups of reads. It can also compute the bias of ramp fitting.
LTdwarfIndices studies spectral indices to determine whether one or more brown dwarfs are photometric variable candidates. For a single brown dwarf, it analyzes a given set of indices and outputs the number of graphs the object appears in in the variable area, whether it is a variable or non-variable candidate, and, optionally, an index-index or histogram plot. Using another code module, LTdwarftIndices can also analyze a set of sample indices for many brown dwarfs.
EF-TIGRE (Effective Field Theory of Interacting dark energy with Gravitational REdshift) constrains interacting Dark Energy/Dark Matter models in the Effective Field Theory framework through Large Scale Structures observables. In particular, the observables include the effect of gravitational redshift, a distortion of time from galaxy clustering. This generates a dipole in the correlation function which is detectable with two distinct populations of galaxies, thus making it possible to break degeneracies among parameters of the EFT description.
sunbather simulates the upper atmospheres of exoplanets and their observational signatures. The code constructs 1D Parker wind profiles using p-winds (ascl:2111.011) to simulate these with Cloudy (ascl:9910.001), and postprocesses the output with a custom radiative transfer module to predict the transmission spectra of exoplanets.
autoregressive-bbh-inference, written in Python, models the distributions of binary black hole masses, spins, and redshifts to identify physical features appearing in these distributions without the need for strongly-parametrized population models. This allows not only agnostic study of the “known unknowns” of the black hole population but also reveals the “unknown unknowns," the unexpected and impactful features that may otherwise be missed by the standard building-block method.
AFINO (Automated Flare Inference of Oscillations) finds oscillations in time series data using a Fourier-based model comparison approach. The code analyzes the date and generates a results file in either JSON or Pickle format, which contains numerous properties of the data and analysis, and a summary plot.
coronagraph_noise simulates coronagraph noise. Written in IDL, the code includes a generalized coronagraph routine and simulators for the WFIRST Shaped Pupil Coronagraph in both spectroscopy and imaging modes. Functions available include stellar and planetary flux functions, planet photon and zodiacal light count rates, planet-star flux ratio, and clock induced charge count rate, among others. coronagraph_noise also includes routines to smooth a plot by convolving with a Gaussian profile to convolve a spectrum with a given instrument resolution and to take a spectrum that is specified at high spectral resolution and degrade it to a lower resolution. A Python implementation of coronagraph_noise, coronagraph (ascl:2405.019), is also available.
coronagraph provides a Python noise model for directly imaging exoplanets with a coronagraph-equipped telescope. Based on the original IDL code for this coronagraph model, coronograph_noise (ascl:2405.018), the Python version has been expanded in a few key ways. Most notably, the Telescope, Planet, and Star objects used for reflected light coronagraph noise modeling can now be used for transmission and emission spectroscopy noise modeling, making this model a general purpose exoplanet noise model for many different types of observations.
tapify implements a suite of multitaper spectral estimation techniques for analyzing time series data. It supports analysis of both evenly and unevenly sampled time series data. The multitaper statistic tackles the problems of bias and consistency, which makes it an improvement over the classical periodogram for evenly sampled data and the Lomb-Scargle periodogram for uneven sampling. In basic statistical terms, this estimator provides a confident look at the properties of a time series in the frequency or Fourier domain.
PALpy provides a Python interface to PAL, the positional Astronomy Library (ascl:1606.002), which is written in C. All arguments modified by the C API are returned and none are modified. The one routine that is different is palObs, which returns a simple dict that can be searched using standard Python. The keys to the dict are the short names and the values are another dict with keys name, long, lat and height.
blackthorn generates spectra of dark matter annihilations into right-handed (RH) neutrinos or into particles that result from their decay. These spectra include photons, positrons, and neutrinos. The code provides support for varied RH-neutrino masses ranging from MeV to TeV by incorporating hazma, PPPC4DMID, and HDMSpectra models to compute dark matter annihilation cross sections and mediator decay widths. blackthorn also computes decay branching fractions and partial decay widths.
raccoon implements the cross-correlation function (CCF) method. It builds weighted binary masks from a stellar spectrum template, computes the CCF of stellar spectra with a mask, and derives radial velocities (RVs) and activity indicators from the CCF. raccoon is mainly implemented in Python 3; it also uses some Fortran subroutines that are called from Python.
Would you like to view a random code?