Xsmurf is a software package written in C/Tcl/Tk that implements the continuous wavelet transform modulus maxima method, an image processing tool for measuring fractal and multifractal properties in experimental and simulation data.
Multifractal analysis is described in the following page: http://www.scholarpedia.org/article/Wavelet-based_multifractal_analysis

Xsmurf has been used in multiple applications in astrophysics, e.g. :
- analysis of solar magnetograms for characterizing complexity of evolving regions
- fractal/multifractal nature and anisotropic structure of Galactic atomic hydrogen (H I)
- analysis of simulation data (velocity field, ...) of turbulent flow

This Python package allows the user to setup and run an agent-based simulation of a SETI survey. The package allows the creation of a population of observing and transmitting civilisations. Each transmitter and observer conducts their activities according to an input strategy. The success of observers and transmitters can then be recorded, and multiple simulations can be run for Monte Carlo Realisation.

This package is therefore a flexible framework in which to simulate and test different SETI strategies, both as an Observer and as a Transmitter. It is primarily designed with radio SETI in mind, but is sufficiently flexible to simulate all forms of electromagnetic SETI, and potentially neutrino and gravitational wave SETI.

A python interface to the JINA reaclib nuclear reaction database

ExoPlanet provides a graphical interface for the construction, evaluation and application of a machine learning model in predictive analysis. With the back-end built using the numpy and scikit-learn libraries, ExoPlanet couples fast and well tested algorithms, a UI designed over the PyQt framework, and graphs rendered using Matplotlib. This serves to provide the user with a rich interface, rapid analytics and interactive visuals.

ExoPlanet is designed to have a minimal learning curve to allow researchers to focus more on the applicative aspect of machine learning algorithms rather than their implementation details and supports both methods of learning, providing algorithms for unsupervised and supervised training, which may be done with continuous or discrete labels. The parameters of each algorithms can be adjusted to ensure the best fit for the data. Training data is read from a CSV file, and after training is complete, ExoPlanet automates the building of the visual representations for the trained model. Once training and evaluation yield satisfactory results, the model may be used to make data based predictions on a new data set.

HHTpywrapper is a python interface to call the Hilbert–Huang Transform (HHT) MATLAB package. HHT is a time-frequency analysis method to adaptively decompose a signal, that could be generated by non-stationary and/or nonlinear processes, into basis components at different timescales, and then Hilbert transform these components into instantaneous phases, frequencies and amplitudes as functions of time. HHT has been successfully applied to analyzing X-ray quasi-periodic oscillations (QPOs) from the active galactic nucleus RE J1034+396 (Hu et al. 2014) and two black hole X-ray binaries, XTE J1550–564 (Su et al. 2015) and GX 339-4 (Su et al. 2017). HHTpywrapper provides examples of reproducing HHT analysis results in Su et al. (2015) and Su et al. (2017). This project is originated from the Astro Hack Week 2015.

We present Kliko, a Docker based container specification for running one or multiple related compute jobs. The key concepts of Kliko is the encapsulation of data processing software into a container and the formalisation of the input, output and task parameters. Formalisation is realised by bundling a container with a Kliko file, which describes the IO and task parameters. This Kliko container can then be opened and run by a Kliko runner. The Kliko runner will parse the Kliko definition and gather the values for these parameters, for example by requesting user input or pre defined values in a script. Parameters can be various primitive types, for example float, int or the path to a file. This paper will also discuss the implementation of a support library named Kliko which can be used to create Kliko containers, parse Kliko definitions, chain Kliko containers in workflows using, for example, Luigi a workflow manager. The Kliko library can be used inside the container interact with the Kliko runner. Finally this paper will discuss two reference implementations based on Kliko: RODRIGUES, a web based Kliko container schedular and output visualiser specifically for astronomical data, and VerMeerKAT, a multi container workflow data reduction pipeline which is being used as a prototype pipeline for the commisioning of the MeerKAT radio telescope.

loci is a shared library for interpolations in up to 4 dimensions. It is written in C and can be used with C/C++, Python and others. In order to calculate the coefficients of the cubic polynom, only local values are used: The data itself and all combinations of first-order derivatives, i.e. in 2D f_x, f_y and f_xy. This is in contrast to splines, where the coefficients are not calculated using derivatives, but non-local data, which can lead to over-smoothing the result.

Two neural networks were designed to identify hazardous planetesimals that were trained on object trajectories calculated in a cloud computing environment. The first neural network was fully-connected and was trained on the orbital elements (OEs) of real/simulated planetesimals, while the second was a 1-dimensional convolutional neural network that was trained on the position Cartesian coordinates of real/simulated planetesimals. Ultimately, the network trained on OEs had a better performance by identifying one-third of known potentially hazardous objects including the 3 asteroids with the highest chance of impact with Earth (2009 FD, 1999 RQ36, 1950 DA) as established by NASA's Monte Carlo based Sentry system.

The Opik method gives the mean probability of collision of a small body with a given planet. It is a statistical value valid for an orbit with given (a,e,i) and undefined argument of perihelion. In some cases, the planet can eject the small body from the solar system; in these cases, the program estimates the mean time for the ejection. The Opik method does not take into account other perturbers than the planet considered, so it only provides an idea of the timescales involved.

pydftools is a pure-python port of the dftools R package (ascl:1805.002), which finds the most likely P parameters of a D-dimensional distribution function (DF) generating N objects, where each object is specified by D observables with measurement uncertainties. For instance, if the objects are galaxies, it can fit a MF (P=1), a mass-size distribution (P=2) or the mass-spin-morphology distribution (P=3). Unlike most common fitting approaches, this method accurately accounts for measurement in uncertainties and complex selection functions. Though this package imitates the dftools package quite closely while being as Pythonic as possible, it has not implemented 2D+ nor non-parametric.

The Matlab Tool generates a 3D model (WRL, texturized in height false color map) of a defined region of the Mars surface. It defines the region of interest of the Mars surface (by Lat Long), a resolution of the MOLA DTMs to be considered (with a minimum px onground of 468 m), a scale factor to be multiplied to the height of the surface to improve features visibility for bumping or shadowing effect.

stginga customizes Ginga to aid data analysis for the data supported by STScI (e.g., HST or JWST). For instance, it provides plugins and configuration files that understand HST and JWST data products.

Astrochemistry database of chemical species.

BELLAMY is a cross-matching algorithm designed primarily for radio images, that aims to match all sources in the supplied target catalogue to sources in a reference catalogue by calculating the probability of a match. BELLAMY utilises not only the position of a source on the sky, but also the flux data to calculate this probability, determining the most probable match in the reference catalog to the target source. Additionally, BELLAMY attempts to undo any spatial distortion that may be affecting the target catalogue, by creating a model of the offsets of matched sources which is then applied to unmatched sources. This combines to produce an iterative cross-matching algorithm that provides the user with an obvious measure of how confident they should be with the results of a cross-match.

MiraPy is a Python package for problem-solving in astronomy using Deep Learning for astrophysicist, researchers and students. Current applications of MiraPy are X-Ray Binary classification, ATLAS variable star feature classification, OGLE variable star light-curve classification, HTRU1 dataset classification and Astronomical image reconstruction using encoder-decoder network. It also contains modules for loading various datasets, curve-fitting, visualization and other utilities. It is built using Keras for developing ML models to run on CPU and GPU seamlessly.

SACC (Save All Correlations and Covariances) is a format and reference library for general storage
of summary statistic measurements for the Dark Energy Science Collaboration (DESC) within and from the Large Synoptic Survey Telescope (LSST) project's Dark Energy Science Collaboration.

We have developed a method to efficiently simulate the dynamics of the magnetic flux in the solar network. We call this method Network Flux Transport (NFT). Implemented using a Spherical Centroidal Voronoi Tessellation (SCVT) based network model, magnetic flux is advected by photospheric plasma velocity fields according to the geometry of the SCVT model. We test NFT by simulating the magnetism of the Solar poles. The poles of the sun above 55 deg latitude are free from flux emergence from active regions or ephemeral regions. As such, they are ideal targets for a simplified simulation that relies on the strengths of the NFT model. This simulation method reproduces the magnetic and spatial distributions for the solar poles over two full solar cycles.

PyFOSC is a pipeline toolbox for long-slit spectroscopy data reduction written in Python. It can be used for FOSC (Faint Object Spectrograph and Camera) data from Xinglong/Lijiang 2-meter telescopes in China. This pipeline privodes a neat way for data pre-processing, including updating missing header fileds for BFOSC data, reducing fits file extension for YFOSC data, etc. And it makes the data reduction procedure efficient by using previously identified lamp spectra as re-identification references during wavelength calibration, and applying multiprocessing in some modules. PyFOSC also enables customization for any other long-slit spectroscopy data.

The heterogeneity of papers dealing with the discovery and characterization of exoplanets makes every attempt to maintain a uniform exoplanet catalog almost impossible. Four sources currently available online (NASA Exoplanet Archive, Exoplanet Orbit Database, Exoplanet Encyclopaedia, and Open Exoplanet Catalogue) are commonly used by the community, but they can hardly be compared, due to discrepancies in notations and selection criteria.
Exo-MerCat is a Python code that collects and selects the most precise measurement for all interesting planetary and orbital parameters contained in the four databases, accounting for the presence of multiple aliases for the same target. It can download information about the host star as well by the use of Virtual Observatory ConeSearch connections to the major archives such as SIMBAD and those available in VizieR. A Graphical User Interface is provided to filter data based on the user's constraints and generate automatic plots that are commonly used in the exoplanetary community.
With Exo-MerCat, we retrieved a unique catalog that merges information from the four main databases, standardizing the output and handling notation differences issues. Exo-MerCat can correct as many issues that prevent a direct correspondence between multiple items in the four databases as possible, with the available data. The catalog is available as a VO resource for everyone to use and it is periodically updated, according to the update rates of the source catalogs.

Since early 2018, the Kepler/K2 project has been performing a uniform global reprocessing of data from K2 Campaigns 0 through 14. Subsequent K2 campaigns (C15-C19) are being processed using the same processing pipeline. One of the major benefits of the reprocessing effort is that, for the first time, short-cadence (1-min) light curves are produced in addition to the standard long-cadence (30-min) light curves. Users have been cautioned that the Kepler pipeline detrending module (PDC), developed for use on original Kepler data, has not been tailored for use on short-cadence K2 observations. Systematics due to events on fast timescales, such as thruster firings, are sometimes poorly corrected for many short-cadence targets. A Python data visualization and manipulation tool, called Kepler-K2 Cadence Events, has been developed that identifies and removes cadences associated with problematic thruster events, thus producing better light curves. Kepler-K2 Cadence Events can be used to visualize and manipulate light curve files and target pixel files from the Kepler, K2, and TESS missions. This software is available at the following NASA GitHub repository https://github.com/nasa/K2CE .

Dual Active Nuclei Galaxies (DAGNs) are rare occurrences in the sky. Until now, most AGNs have been described to be found serendipitously, or by manual observation. In recent years, there has been an increasing interest in such dual AGNs and their astrophysical properties. Their study is important to the understanding of galaxy formation, star formation and these objects are the precursors to Gravitational Wave Sources.

Hence, we have devised a pipeline, that along with systematic data collection, can detect such dual AGN candidates. A novel algorithm 'Graph-Boosted Gradient Ascent' has been devised to detect whether an R-band image of a galaxy is a potential candidate for a DAGN or not. The pipeline can be cloned to a user's machine, and by joining the AstrIRG_DAGN group on SciServer, astronomers can collectively contribute to the mining of DAGNs.

Time-domain astronomy sandbox consists in a series of classes to simulate and process time-domain astronomy data products in Python. The code was originally developed to model Fast Radio Burst (FRB) and Radio Frequency Interference (RFI), and evaluate different RFI mitigation methods and their effect on FRB search.

amber_meta integrates a few routines to launch AMBER (ascl:2209.007) in a systematic manner. To avoid typing a string in the command line manually with all parameters required to launch AMBER, amber_meta generates the command from configuration files, and can directly launch AMBER instances.

StarburstPy is a python wrapper for Starburst99 (ascl:1104.003). The code contains methods for setting all inputs, running Starburst99, and reading output data into python dictionaries.

The project is a simple Python client for Cosmicflows-3 Distance-Velocity Calculator at distances less than 400 Mpc (http://edd.ifa.hawaii.edu/CF3calculator/)

Compute expectation distances or velocities based on smoothed velocity field from the Wiener filter model of https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.5438G/abstract.

MERA works with large 3D AMR/uniform-grid and N-body particle data sets from astrophysical simulations such as those produced by the hydrodynamic code RAMSES (ascl:1011.007) and is written entirely in the Julia language. The package provides essential functions for efficient and memory lightweight data loading and analysis. The core of MERA is a database framework.

The protocol describes the algorithm of arriving at LOD in a given past geological Epoch. First the lunar orbital radius of the given geologic epoch has to be determined. For this the velocity of recession of Moon for the accelerated phase has to be determined. The spatial integral of the reciprocal of Velocity of recession gives the the transit time of Moon from desired orbit to the present orbit.Through several iterations the transit time is made to converge on the geologic epoch. Once we determine the desired orbital radius it has to be substituted in the LOD expression to determine the LOD in the given geologic epoch.

SoFiAX is a web-based platform to merge and interact with the results of parallel execution of SoFiA HI source finding software [ascl:1412.001] and other steps of processing ASKAP Wallaby HI survey data.

ExoPix is a collection of tutorials aimed at illustrating the imaging of exoplanets with the James Webb Space Telescope (JWST). ExoPix tutorials are meant to demonstrate the application of the PSF-subtraction algorithm pyKLIP (ascl:1506.001) to simulated JWST NIRCAM data. We provide simple walkthroughs of pyKLIP’s ability to reveal exoplanets, compute contrast curves, and measure exoplanet astrometry and photometry in imaged extrasolar systems.

The Exoplanet Modeling and Analysis Center (EMAC) is a website which serves as a catalog, repository and integration platform for modeling and analysis resources focused on the study of exoplanet characteristics and environments. EMAC hosts user-submitted software ranging in category from planetary interior models to data visualization tools. Other features of EMAC include integrated web tools developed by the EMAC team in collaboration with the tools' original authors and video demonstrations of a growing number of hosted tools. EMAC aims to be a comprehensive repository for researchers to access a variety of exoplanet resources that can assist them in their work, and currently hosts a growing number of code bases, models, and tools. EMAC is a key project of the NASA GSFC Sellers Exoplanet Environments Collaboration (SEEC).

FLARE, a parallel code written in Python, generates 100,000 Fast Radio Bursts (FRB) using the Monte Carlo method. The FRB population is diverse and includes sporadic FRBs, repeaters, and periodic repeaters. However, less than 200 FRBs have been detected to date, which makes understanding the FRB population difficult. To tackle this problem, FLARE uses a Monte Carlo method to generate 100,000 realistic FRBs, which can be analyzed later on for further research. It has the capability to simulate FRB distances (based on the observed FRB distance range), energies (based on the "flaring magnetar model" of FRBs), fluences, multi-wavelength counterparts (based on x-ray to radio fluence ratio of FRB 200428), and other properties. It analyzes the resulting synthetic FRB catalog and displays the distribution of their properties. It is fast (as a result of parallel code) and requires minimal human interaction. FLARE is, therefore, able to give a broad picture of the FRB population.

USNO/AE98 contains ephemerides for fifteen of the largest asteroids that The Astronomical Almanac has used since its 2000 edition. These ephemerides are based on the Jet Propulsion Laboratory (JPL) planetary ephemeris DE405 and, thus, aligned to the International Celestial Reference System (ICRS). The data cover the period from 1799 November 16 (JD 2378450.5) through 2100 February 1 (JD 2488100.5). The internal uncertainty in the mean longitude at epoch, 1997 December 18, ranges from 0.05 arcseconds for 7 Iris through 0.22 arcseconds for 65 Cybele, and the uncertainty in the mean motion varies from 0.02 arcseconds per century for 4 Vesta to 0.14 arcseconds per century for 511 Davida.

The Astronomical Almanac has published ephemerides for 1 Ceres, 2 Pallas, 3 Juno, and 4 Vesta since its 1953 edition. Historically, these four asteroids have been observed more than any of the others. Ceres, Pallas, and Vesta deserve such attention because as they are the three most massive asteroids, the source of significant perturbations of the planets, the largest in linear size, and among the brightest main belt asteroids. Studying asteroids may provide clues to the origin and primordial composition of the solar system, data for modeling the chaotic dynamics of small solar system bodies, and assessments of potential collisions. Therefore, USNO/AE98 includes more than the traditional four asteroids.

The following criteria were used to select main belt asteroids for USNO/AE98:

Diameter greater than 300 km, presumably among the most massive asteroids
Excellent observing history and discovered before 1850
Largest in their taxonomic class
The massive asteroids included may be studied for their perturbing effects on the planets while those with detailed observing histories may be used to evaluate the accuracy limits of asteroid ephemerides. The fifteen asteroids that met at least one of these criteria are

1 Ceres (new mass determination)
2 Pallas (new mass determination)
3 Juno
4 Vesta (new mass determination)
6 Hebe
7 Iris
8 Flora
9 Metis
10 Hygiea
15 Eunomia
16 Psyche
52 Europa
65 Cybele
511 Davida
704 Interamnia
The refereed paper by Hilton (1999, Astron. J. 117, 1077) describes the USNO/AE98 asteroid ephemerides in detail. The associated USNO/AA Tech Note 1998-12 includes residual plots for all fifteen asteroids and a comparison between these ephemerides and those used in The Astronomical Almanac through 1999.

Software to compact, read, and interpolate the USNO/AE98 asteroid ephemerides is also available. It is written in C and designed to work with the C edition of the Naval Observatory Vector Astrometry Software (NOVAS). The programs could be used with tabular ephemerides of other asteroids as well. The associated README file provides the details of this system.

The synchrofit (synchrotron fitter) package implements a reduced dimensionality parameterisation of standard synchrotron spectrum models, and provides fitting routines applicable for active galactic nuclei and supernova remnants. The Python code includes the Jaffe-Parola model (JP), Kardashev-Pacholczyk model (KP), and continuous injection models (CI/KGJP) for both constant or Maxwell-Boltzmann magnetic field distributions. An adaptive maximum likelihood algorithm is invoked to fit these models to multi-frequency radio observations; the adaptive mesh is customisable for either optimal precision or computational efficiency. Functions are additionally provided to plot the fitted spectral model with its confidence interval, and to derive the spectral age of the synchrotron emitting particles.

Characterize and understandOpen Clusters(OCs) allow us to understand better properties and mechanisms about the Universe such as stellar formation and the regions where these events occur. They also provide information about stellar processes and the evolution of the galactic disk.

In this paper, we present a novel method to characterize OCs. Our method employs a model built on Artificial Neural Networks(ANNs). More specifically, we adapted a state of the art model, the Deep Embedded Clustering(DEC) model for our purpose. The developed method aims to improve classical state of the arts techniques. We improved not only in terms of computational efficiency (with lower computational requirements), but inusability (reducing the number of hyperparameters to get a good characterization of the analyzed clusters). For our experiments, we used the Gaia DR2 database as the data source, and compared our model with the clustering technique K-Means. Our method achieves good results, becoming even better (in some of the cases) than current techniques.

The MRS (The MOS Reduction Software) suite reduces the spectra taken with the multi-object spectrograph spectra used as the focal plane instrument of RTT150 telescope in the TÜBİTAK National Observatory.

Simple program for planning and managing astronomical observations as observational diary or logs.

Ulula is an ultra-lightweight 2D hydro code for teaching purposes. The code is written in pure python and is designed to be as short and easy to understand as possible, while not compromising on performance. The latter is achieved with a simple Godunov solver and by using numpy for all array operations.

Phase Dispersion Minimization (PDM) is a periodical signal detection method, and it is originally implemented by Stellingwerf with C (https://www.stellingwerf.com/rfs-bin/index.cgi?action=PageView&id=34). With the help of Cython, Py-PDM is much faster than other Python implementations.

GalaXimView (for Galaxies Simulations Viewer) is a python3+matplotlib tool designed to visualise simulations which use particles, providing notably a rotatable 3D view and corresponding projections in 2D, together with a way of navigating through snapshots of a simulation keeping the same projection.

MALU visualizes integral field spectroscopy (IFS) data such as CALIFA, MANGA, SAMI or MUSE data producing fully interactive plots. The tool is not specific to any instrument. It is available in Python and no installation is required.

This module implements an ad-hoc grism-based spectrograph optical model. It provides a flexible chromatic mapping between the input focal plane and the output detector plane, based on an effective simplified ray-tracing model of the key optical elements defining the spectrograph (collimator, prism, grating, camera), described by a restricted number of physically-motivated distortion parameters.

An attempt at creating a common pythonic framework for visual and infrared telescope instrument data simulators.

Templates and helper functions for creating on-sky Source description objects for the ScopeSim instrument data simulation engine.

A reference database for astronomical instrument and telescope characteristics for all types of visual and infrared systems. Instrument packages are used in conjunction with the ScopeSim instrument data simulator.

A python package created around Eric Gendron’s code for analytically (and quickly) generating field-varying SCAO PSFs for the ELT.

A super lightweight interface in Python to load spectra from the Pickles 1998 (stellar) and Brown 2014 (galactic) spectral catalogues

As a new generation of large-scale telescopes are expected to produce single data products in the range of hundreds of GBs to multiple TBs, different approaches to I/O efficient data interaction and extraction need to be investigated and made available to researchers. This will become increasingly important as the downloading and distribution of TB scale data products will become unsustainable, and researchers will have to take their processing analysis to the data. We present a methodology to extract 3 dimensional spatial-spectral data from dimensionally modelled tables in Parquet format on a Hadoop system. The data is loaded into the Parquet tables from FITS cube files using a dedicated process. We compare the performance of extracting data using the Apache Spark parallel compute framework on top of the Parquet-Hadoop ecosystem with data extraction from the original source files on a shared file system. We have found that the Spark-Parquet-Hadoop solution provides significant performance benefits, particularly in a multi user environment. We present a detailed analysis of the single and multi-user experiments conducted and also discuss the benefits and limitations of the platform used for this study.

The caustic technique is a powerful method to infer cluster mass profiles to clustrocentric distances well beyond the virial radius. It relies in the measure of the escape velocity of the sistem using only galaxy redshift information. This method was introduced by Diaferio & Geller (1997) and Diaferio (1999). This code allows the caustic mass estimation for galaxy clusters, as well as outlier identification as a side effect. However, a pre-cleaning of interlopers is recommended, using e.g., the shifting-gapper technique.

An internally overhauled but fundamentally similar version of Forecaster by Jingjing Chen and David Kipping, originally presented in arXiv:1603.08614 and hosted at https://github.com/chenjj2/forecaster.

The model itself has not changed- no new data was included and the hyperparameter file was not regenerated. All functions were rewritten to take advantage of Numpy vectorization and some additional user features were added. Now able to be installed via pip.

DIPol-UF provides tools for remote control and operation of DIPol-UF, an optical (BVR) imaging CCD polarimeter. The project contains libraries that handle low-level interoperation with ANDOR SDK (provided by the CCD manufacturer), communication with stepper motors (which perform plate rotations), FITS file serialization/deserialization, over-network communication between different system components (each CCD is connected to a standalone PC), as well as provide GUI (built with WPF).

CHIME/FRB instrument has recently published a catalog containing about half of thousand fast radio bursts (FRB) including their spectra and several reconstructed properties, like signal widths, amplitudes, etc. We have developed a model-independent approach for the classification of these bursts using cross-correlation and clustering algorithms applied to one-dimensional intensity profiles, i.e. to amplitudes as a function of time averaged over the frequency. This approach is implemented in frbmclust package, which is used for classification of bursts featuring different waveform morphology.

Site with collection of codes and fundamental references on mean motion resonances.

The Roman Coronagraph Exposure Time Calculator (Roman_Coronagraph_ETC for short) is the public version of the exposure time calculator of the Coronagraph Instrument aboard the Nancy Grace Roman Space Telescope funded by NASA. The methods used to estimate the integration times are based upon peer reviewed research articles (see Bibliography) and a collection of instrumental and modeling parameters of both the Coronagraph Instrument and the Nancy Grace Roman Space Telescope. The code is written in python. Visit https://github.com/hsergi/Roman_Coronagraph_ETC for more information.

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.

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.

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

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).

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.

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

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.

BMarXiv scans new (i.e., since the last time checked) submissions from arXiv, ranks submissions based on keyword matches, and produces an HTML page as an output.

The keywords are looked for (with regex capabilities) in the title, abstract, but also the author list, so it is possible to look for people too. The score is calculated for each specific entry but additional (and optional) scoring is performed using the first author recent submissions and/or the other authors' recent submissions.

It is possible to include/exclude any arXiv categories (within astro-ph or not). New astronomical conferences (from CADC by default) and new codes (from ASCL.net) are also checked and can also be scanned for keywords.

A local bibliography file can be scanned to find frequent words/groups of words that could become scanned keywords.

Eidein interactively visualizes a data sample for the selection of an informative (contains data with high predictive uncertainty, is diverse, but not redundant) data subsample for deep active learning. The data sample is projected to 2-D with a dimensionality reduction technique. It is visualized in an interactive scatter plot that allows a human expert to select and annotate the data subsample.

EleFits is a modern C++ package to read and write FITS files which focuses on safety, user-friendliness, and performance.

Many fields in science and engineering measure data that inherently live on non-Euclidean geometries, such as the sphere. Techniques developed in the Euclidean setting must be extended to other geometries. Due to recent interest in geometric deep learning, analogues of Euclidean techniques must also handle general manifolds or graphs. Often, data are only observed over partial regions of manifolds, and thus standard whole-manifold techniques may not yield accurate predictions. In this thesis, a new wavelet basis is designed for datasets like these.

Although many definitions of spherical convolutions exist, none fully emulate the Euclidean definition. A novel spherical convolution is developed, designed to tackle the shortcomings of existing methods. The so-called sifting convolution exploits the sifting property of the Dirac delta and follows by the inner product of a function with the translated version of another. This translation operator is analogous to the Euclidean translation in harmonic space and exhibits some useful properties. In particular, the sifting convolution supports directional kernels; has an output that remains on the sphere; and is efficient to compute. The convolution is entirely generic and thus may be used with any set of basis functions. An application of the sifting convolution with a topographic map of the Earth demonstrates that it supports directional kernels to perform anisotropic filtering.

Slepian wavelets are built upon the eigenfunctions of the Slepian concentration problem of the manifold - a set of bandlimited functions which are maximally concentrated within a given region. Wavelets are constructed through a tiling of the Slepian harmonic line by leveraging the existing scale-discretised framework. A straightforward denoising formalism demonstrates a boost in signal-to-noise for both a spherical and general manifold example. Whilst these wavelets were inspired by spherical datasets, like in cosmology, the wavelet construction may be utilised for manifold or graph data.

unWISE-verse is an integrated Python pipeline for downloading sets of unWISE time-resolved coadd cutouts from the WiseView image service and uploading subjects to Zooniverse.org for use in astronomical citizen science research. This software was initially designed for the Backyard Worlds: Cool Neighbors research project and is optimized for target sets containing low luminosity brown dwarf candidates. However, unWISE-verse can be applied to other future astronomical research projects that seek to make use of unWISE infrared sky maps, such as studies of infrared variable/transient sources.

nFITSview is a simple, user-friendly and open-source FITS image viewer available for Linux and Windows. One of the main concepts of nFITSview is to provide an intuitive user interface which may be helpful both for scientists and for amateur astronomers. nFITSview has different color mapping and manipulation schemes, supports different formats of FITS data files as well as exporting them to different popular image formats. It also supports command-line exporting (with some restrictions) of FITS files to other image formats.
The application is written in C++/Qt for achieving better performance, and with every next version the performance aspect is taken into account.
nFITSview uses its own libnfits library (can be used separately as well) for parsing the FITS files.

PREVIS is a Python module that provides functions to help determine the observability of astronomical sources from long-baseline interferometers worldwide: VLTI (ESO, Chile) and CHARA (USA). PREVIS uses data from the Virtual Observatory (OV), such as magnitudes, Spectral Energy Distribution (SED), celestial coordinates or Gaia distances. Then, it compares the target brightness to the limiting magnitudes of each instrument to determine whether the target is observable with present performances. PREVIS includes main facilities at the VLTI with PIONIER (H band), GRAVITY (K band) and MATISSE (L, M, N bands), and at CHARA array with VEGA (V band), PAVO (R bands), MIRC (H band), CLIMB (K band) and CLASSIC (H, K bands). PREVIS also uses the V or G magnitudes to check the guiding restriction or the tip/tilt correction limit. For the VLTI: if the star is too faint in G mag, PREVIS will look for the list of stars around the target (57 arcsec) with the appropriate magnitude and give the list of celestial coordinates usable as the guiding star.

World Observatory visualizes S/N-versus-cost tradeoffs for large optical and near-infrared telescopes. Both mid-latitude and Arctic/Antarctic sites can be considered; the intent is a simple simulation to grow intuition for where major capital costs lie relative to key observatory design choices, and against expected scientific performance at various sites. User-defined unit costs for (a possibly "effective") roadway, enclosure, aperture, focal length, and adaptive optics can be scaled up for polar sites, and down for better seeing and lower sky brightness in K-band. Observatory models and results are immediately displayed side-by-side. Either point-source-detection S/N or recovery of bulge-to-total ratios in a simulated galaxy survey are divided by the total project cost, thus providing a universal metric.

Latest version of TS (Turbospectrum), with NLTE capabilities.
Computation of stellar spectra (flux and intensities) in 1D or average stellar atmosphere models.
In order to compute NLTE stellar spectra, additional data is needed, downloadable outside GitHub.
See documentation in DOC folder

Python wrappers are available at https://github.com/EkaterinaSe/TurboSpectrum-Wrapper/ and https://github.com/JGerbs13/TSFitPy
They allow interpolation between models and fitting of spectra to derive stellar parameters.

Coniferest is a Python package designed for implementing anomaly detection algorithms and interactive active learning tools. The centerpiece of the package is an Isolation Forest algorithm, known for its superior scoring performance and multi-threading evaluation. This robust anomaly detection algorithm operates by constructing random decision trees.

In addition to the Isolation Forest algorithm, Coniferest also offers two modified versions for active learning: AAD Forest and Pineforest. The AAD Forest modifies the Isolation Forest by reweighting its leaves based on responses from human experts, providing a faster alternative to the ad_examples package.

On the other hand, Pineforest, developed by the SNAD team, employs a filtering algorithm that builds and dismantles trees with each new human-machine iteration step.

Coniferest provides a user-friendly interface for conducting interactive human-machine sessions, facilitating the use of these active anomaly detection algorithms. The SNAD team maintains and utilizes this package primarily for anomaly detection in the field of astronomy, with a particular focus on light-curve data from large time-domain surveys.

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

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

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

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

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

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

prodimopy is an open-source Python package to read, analyze and plot modelling results of the radiation thermo-chemical disk code ProDiMo (PROtoplanetary DIsk MOdel, https://prodimo.iwf.oeaw.ac.at). It also includes tools to run ProDiMo in 1D slap model mode, to run simple ProDimo model grids and to interface ProDiMo with 1D and 2D disk codes (i.e. use input structure from hydrodynamic models).

prodimopy can also be used independently of ProDiMo (no ProDiMo installation is required) and hence is also useful to extract information from already available ProDiMo models (e.g. as input for other codes) or for model comparison.

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.

A fast GPU-based bispectrum estimator implemented using JAX.

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.

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

Flash-X simulates physical phenomena in several scientific domains, primarily those involving compressible or incompressible reactive flows, using Eulerian adaptive mesh and particle techniques. It derives some of its solvers from and is a descendant of FLASH (ascl:1010.082). Flash-X has a new framework that relies on abstractions and asynchronous communications for performance portability across a range of heterogeneous hardware platforms, including exascale machines. It also includes new physics capabilities, such as the Spark general relativistic magnetohydrodynamics (GRMHD) solver, and supports interoperation with the AMReX mesh framework, the HYPRE linear solver package, and the Thornado neutrino radiation hydrodynamics package, among others.

ELISA is a Python library designed for efficient spectral modeling and robust statistical inference. With user-friendly interface, ELISA streamlines the spectral analysis workflow.

The modeling framework of ELISA is flexible, allowing users to construct complex models by combining models of ELISA and XSPEC, as well as custom models. Parameters across different model components can also be linked. The models can be fitted to the spectral datasets using either Bayesian or maximum likelihood approaches. For Bayesian fitting, ELISA incorporates advanced Markov Chain Monte Carlo (MCMC) algorithms, including the No-U-Turn Sampler (NUTS), nested sampling, and affine-invariant ensemble sampling, to tackle the posterior sampling problem. For maximum likelihood estimation (MLE), ELISA includes two robust algorithms: the Levenberg-Marquardt algorithm and the Migrad algorithm from Minuit. The computation backend is based on Google's JAX, a high-performance numerical computing library, which can reduce the runtime for fitting procedures like MCMC, thereby enhancing the efficiency of analysis.

After fitting, goodness-of-fit assessment can be done with a single function call, which automatically conducts posterior predictive checks and leave-one-out cross-validation for Bayesian models, or parametric bootstrap for MLE. These methods offer greater accuracy and reliability than traditional fit-statistic/dof measures, and thus better model discovery capability. For comparing multiple candidate models, ELISA provides robust Bayesian tools such as the Widely Applicable Information Criterion (WAIC) and the Leave-One-Out Information Criterion (LOOIC), which are more reliable than AIC or BIC. Thanks to the object-oriented design, collecting the analysis results should be simple. ELISA also provide visualization tools to generate ready-for-publication figures.

ELISA is an open-source project and community contributions are welcome and greatly appreciated.

Global mm-VLBI Array (GMVA) observations are accompanied by a lot of metadata (i.e., the so-called 'ANTAB' files) that contain the system temperature (Tsys) and the gain values of the individual GMVA antennas. These data are required for the amplitude calibration of GMVA data which is an essential part in the data reduction. Unfortunately, Tsys measurements in the ANTAB files are not perfect and there are almost always erroneous values in some of the ANTAB files (particularly in the VLBA data). This could lead to incorrect results in the amplitude calibration and thus need to be corrected with proper data inspection/treatment. However, every GMVA station provides the ANTAB file in their own data format which makes the examination tricky. AntabGMVA was designed to resolve these issues and allows GMVA users to manage the GMVA ANTAB files easily and efficiently. Using AntabGMVA, one can perform extraction/inspection/visualization/correction of the Tsys data from the ANTAB files and finally generate one single ANTAB file which includes all the final products.

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

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

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

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

Extensible spacetime agnostic general relativistic ray-tracing (GRRT): Gradus.jl is a suite of tools related to tracing geodesics and calculating observational signatures of accreting compact objects. Gradus.jl requires only a specification of the non-zero metric components of a chosen spacetime in order to solve the geodesic equation and compute a wide variety of trajectories and orbits. Various algorithms for calculating physical quantities are implemented generically, so they may be used with different classes of spacetime with minimal effort.

**Finalflash** is a Python package designed for primary beam corrections of uGMRT radio interferometric images. The software uses frequency-dependent beam models and FITS file handling to improve the accuracy of radio astronomical data. It is open source and available under the MIT License. The code is hosted at https://github.com/arpan-52/Finalflash.

This notebook provides a comprehensive approach for analyzing and visualizing astronomical data from FITS (Flexible Image Transport System) files, focusing on moment maps derived from molecular line emissions within the galaxy NGC 0628. The analysis involves applying various image processing techniques to handle corrupted pixels, reconstruct images, and enhance the quality of moment maps. The notebook also demonstrates how to simulate super-resolution to improve the spatial resolution of the data. By utilizing Gaussian filtering, median filtering, and contrast enhancement, the approach improves the clarity and precision of the data, making it suitable for detailed astrophysical studies. This tool serves as an efficient method for processing and visualizing large-scale astronomical datasets for further analysis and scientific interpretation.

This project presents a comprehensive spectroscopic analysis of O and B-type stars, neutron stars, and white dwarfs, with a focus on the detection of helium (He) and oxygen (O) in stellar atmospheres. By leveraging data from the Sloan Digital Sky Survey (SDSS) and utilizing tools such as Astropy, Astroquery, and Specutils, the project aims to identify key spectral lines of helium and oxygen, as well as the formation of heliox (OHe) molecules. The methodology involves querying SDSS for relevant spectral data, filtering and analyzing it based on stellar classification, and visualizing the results using advanced techniques. The findings contribute to the understanding of stellar evolution, chemical processes, and the role of these elements in various stellar classes. Additionally, the project incorporates interactive data exploration with Aladin Lite and Simbad, offering a robust framework for future astrophysical research.

Colume (COLUMn to vOLUME) uses the statistical and spatial distribution of a column density map to infer a likely volume density distribution along each line of sight. This Python package incorporates all pre-processing (in particular re-sampling) functions needed to efficiently work on the column density maps. Colume's outputs are saved in Numpy format.

The euclidlib python package is an unofficial tool designed to read products from the Euclid Consortium Science Ground Segment. Euclidlib offers user-friendly reading and writing routines, and effectively enables to work overall with Large-Scale Structure cosmological products.

easyspec is a tool designed to streamline long-slit spectroscopy, offering an intuitive framework for reducing, extracting, and analyzing astrophysical spectra.

Crimson Light is a tool to visualize and slice metadata on the available archival observations of samples of astrophysical objects. This visualization enables the user to view available multi-wavelength datasets for a range of objects, optionally filtering the displayed observations on the basis of (angular) resolution, wavelength/frequency coverage, and other properties.

Spectool is a toolkit designed for processing astronomical spectral data, offering a collection of common spectral analysis algorithms. The package includes functions for spectral resampling, spectral flattening, radial velocity measurements, spectral convolution broadening, and more. Each function in the package is implemented independently, allowing users to select and utilize the desired features as needed. The functions are designed with simple and intuitive interfaces, ensuring ease of use for various data sets and analysis tasks.

StellarSpecModel is a Python package to interpolate the stellar spectral grid. Users provide stellar parameters (Teff, FeH, logg), the package will return the corresponding stellar spectrum.

This packagge also designed for generating and analyzing theoretical stellar spectral energy distributions (SEDs). The package includes functionality for both single and binary star systems, incorporating extinction models and the ability to handle photometric data in various filter bands.

Spinifex is a pure Python tooling for ionospheric corrections in radio astronomy, e.g. getting total electron content and rotation measures.

The Galaxy Morphology Posterior Estimation Network (GaMPEN) is a Bayesian machine learning framework that can estimate robust posteriors (i.e., values + uncertainties) for structural parameters of galaxies. GaMPEN also automatically crops input images to an optimal size before structural parameter estimation.

GaMPEN’s predicted posteriors are extremely well-calibrated (less than 5% deviation) and have been shown to be up to 60% more accurate compared to the uncertainties predicted by many light-profile fitting algorithms.

Once trained, it takes GaMPEN less than a millisecond to perform a single model evaluation on a CPU. Thus, GaMPEN’s posterior prediction capabilities are ready for large galaxy samples expected from upcoming large imaging surveys, such as Rubin-LSST, Euclid, and NGRST.

GaMorNet is a Convolutional Neural Network to classify galaxies morphologically. GaMorNet does not need a large amount of training data (as it is trained on simulations and then transfer-learned on a small portion of real data) and can be applied on multiple datasets. Till now, GaMorNet has been tested on ~100,000 SDSS g-band galaxies and ~20,000 CANDELS H-band galaxies and has a misclassification rate of less than 5%

This repository implements an optimized XGBoost-based framework for photometric classification of Type Ia supernovae, addressing class imbalance through PR-AUC and F1-score prioritization. The approach is designed for scalability in large-scale astronomical surveys such as LSST and ensures improved classification robustness compared to traditional metrics like ROC-AUC.

We present a new algorithm for identifying superbubbles in HI column density maps of both observed and simulated galaxies that has only two adjustable parameters. The algorithm includes an automated galaxy-background separation step to focus the analysis on the galactic disk. To test the algorithm, we compare the superbubbles it finds in a simulated galactic disk with the ones it finds in 21~cm observations of a similar galactic disk. The sizes and radial distribution of those superbubbles are indeed qualitatively similar. However, superbubbles in the simulated galactic disk have lower central H~I column densities. The H~I superbubbles in the simulated disk are spatially associated with pockets of hot gas. We conclude that the algorithm is a promising method for systematically identifying and characterizing superbubbles using only HI column density maps that will enable standardized tests of stellar feedback models used in galaxy simulations.

The Find Emission LINEs tool FELINE combines a fully parallelized galaxy line template
matching with a matched filter approach for individual emission features.
The FELINE algorithm evaluates the likelihood in each spectrum of a 3D data cube for emission lines at the positions provided by a given redshift and a certain combination of typical emission features.
FELINE does not evaluate the observed data cube directly, but instead utilizes the result of an emission line matched filter to boost the signal-to-noise of any such feature in the data cube. FELINE, however, does not pick individual peaks from that data as separate objects but instead simultaneously assesses the accumulative signal at all spectral positions that correspond to a certain set of emission lines at any redshift within the range of interest.

ExoSim 2 is the next generation of the Exoplanet Observation Simulator (ExoSim) tailored for the spectro-photometric observations of transiting exoplanets from space, ground, and sub-orbital platforms. The code execution in ExoSim 2 follows a three-step workflow: the creation of focal planes, the production of Sub-Exposure blocks, and the generation of non-destructive reads (NDRs). ExoSim 2 has demonstrated consistency in estimating photon conversion efficiency, saturation time, and signal generation. The simulator has also been validated independently for instantaneous read-out and jitter simulation, and for astronomical signal representation

The Blooming Tree (BT) algorithm, based on the hierarchical clustering method, is designed to identify clusters, groups, and substructures from galaxy redshift surveys.

XGPaint.jl generates maps of extragalactic foregrounds, using astrophysical models designed to replicate the statistics of the millimeter sky. XGPaint computes simulated galaxies from the Cosmic Infrared Background (CIB), radio galaxies, and contributions and distortions from the Sunyaev-Zeldovich (SZ) effect. XGPaint is multithreaded, and supports both HEALPix and Plate Carrée pixelizations.