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.

KERN is a bi-annually released set of radio astronomical software packages. It should contain most of the standard tools that a radio astronomer needs to work with radio telescope data. The goal of KERN to is to save time and frustration in setting up of scientific pipelines, and to assist in achieving scientific reproducibility.

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.

DENSe is a compact library to enable Bayesian non-parametric inferences of densities of Poisson data counts. Its framework of stateless methods is written in Python, although it relies on Numerical Information Field Theory (NIFTy) for the heavy lifting. DENSe aims at utilizing all the available information in the data by modeling the inherent correlation structure using a Matérn kernel. The inference of the density from count data can be written in a single line of python code. The fitting method takes a multidimensional numpy array as input and returns multidimensional arrays of the same dimensions encoding the density field.

The Atacama Large Millimeter/submillimeter Array (ALMA) is the most advanced astronomical interferometer, operating in the millimeter and submillimeter wavelength regime. Since the start of its operations in 2011, ALMA has contributed to major breakthroughs in astronomy across a wide range of scientific topics, from detailed studies of Solar System objects to the origin and evolution of galaxies across Cosmic Time. ALMA observes hundreds of targets per year at high spatial and spectral resolutions, both in continuum and molecular lines. As part of its legacy, every observed ALMA project is added to its public science archive, with more than 1 PB of data residing on the archive as of 2020. While bearing an enormous potential, the large volume and complexity of these datasets hamper the systematic exploitation of its vast archive.

ALminer is a novel Python-based code that enables users to efficiently query, analyse, and visualize the ALMA Science Archive. Users can programmatically query the archive for positions, target names, or any other keywords in the archive metadata (e.g. proposal title, abstract, scientific category) in a simple way. ALminer's plotting routines allow the query results to be visualised, and its analysis functions allow users to filter the results and check whether certain frequencies of interest are covered in the queried observations. The code also allows users to directly download ALMA data products in FITS format and/or the raw data that can be used for manual image processing. ALminer has been designed to make mining the ALMA archive as simple as possible, while being flexible to be customised according to the user's scientific interests. The code is released with a detailed tutorial Jupyter notebook, introducing ALminer's common functions as well as some of its more advanced options.

ALminer is a collaboration between Allegro, the ALMA Regional Centre in The Netherlands, and the University of Vienna (Austria) as part of the EMERGE ERC-StG project. With the public release of this new software, our goal is to provide the astronomical community with a new easy-to-use toolkit that facilitates the scientific exploitation of the rich ALMA science archive.

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.

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

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.

A simulator for the Next-Generation Space Telescope. The software is used to predict the signal-to-noise and other parameters of imaging and/or spectroscopic observations as a function of telescope size, detector noise etc.

This module implements IMRPhenomD in a pure Python code, compiled with the Numba just-in-time compiler. The structure of the code is closely related to the C code; the module provides nearly identical function interfaces in IMRPhenomD.py. The module implements the analytic first and second derivatives necessary to compute t(f) and t'(f), rather than computing them numerically, as is done in the C code. Using the analytic derivatives increases the code complexity but is wall-time faster and produces more numerically accurate results. The improvement in numerical accuracy is particularly significant for t'(f). In testing, PyIMRPhenomD is considerably faster than the C implementation. For large frequency grids, the Python version's speed-up is typically approximately a factor of 5 compared to the C version.

This module implements the fast forward and inverse WDM wavelet transforms in python from both the time and frequency domains. The frequency domain transforms are inherently faster and more accurate. The wavelet domain->frequency domain and frequency domain->wavelet domain transforms are nearly exact numerical inverses of each other for a variety of inputs tested, including gaussian random noise.

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.

pycrires is a Python wrapper for running the CRIRES+ recipes of EsoRex. The pipeline organizes the raw data, creates SOF and configuration files, runs the calibration and science recipes, and creates plots of the images and extracted spectra. Additionally, it provides functionalities for correcting remaining inaccuracies in the wavelength solution and the spectrum curvature. There are also dedicated methods for extracting 2D spectra that maintain the spatial dimension, for example required for the direct detection of exoplanets.

Python code that reads synthetic "full" spectra and elemental spectra, identifies automatically the detectable lines at a given resolution (provided the linelist used to compute the spectra), characterizes them (purity, central wavelength, depth, etc), then stores them in a pandas DataFrame.

Multi-element interferometers such as MeerKAT, which observe with high time resolution and have a wide field-of-view, provide an ideal opportunity to perform real-time, untargeted transient and pulsar searches. However, because of data storage limitations, it is not always feasible to store the baseband data required to image the field of a discovered transient or pulsar. This limits the ability of surveys to effectively localise their discoveries and may restrict opportunities for follow-up science, especially of one-off events like some Fast Radio Bursts (FRBs). SeeKAT is a Python implementation of a novel maximum-likelihood estimation approach to localising transients and pulsars detected in multiple MeerKAT tied-array beams at once to (sub-)arcsecond precision.

Context. We present a probabilistic cross-correlation approach to estimate time delays in the context of reverberation mapping (RM) of Active Galactic Nuclei (AGN).

Aims. We reformulate the traditional interpolated cross-correlation method as a statistically principled model that delivers a posterior distribution for the delay.

Methods. The method employs Gaussian processes as a model for observed AGN light curves. We describe the mathematical formalism and demonstrate the new approach using both simulated light curves and available RM observations.

Results. The proposed method delivers a posterior distribution for the delay that accounts for observational noise and the non-uniform sampling of the light curves. This feature allow us to fully quantify its uncertainty and propagate it to subsequent calculations of dependant physical quantities, e.g., black hole masses. It delivers out-of-sample predictions, which enables us to subject it to model selection and it can calculate the joint posterior delay for more than two light curves.

Conclusions. Because of the numerous advantages of our reformulation and the simplicity of its application, we anticipate that our method will find favour not only in the specialised community of RM, but in all fields where cross-correlation analysis is performed. We provide the algorithms and examples of their application as part of our Julia GPCC package.

This package contains tools for simulating extra-galactic populations of gravitational waves sources (at the moment BBH only) and model their emission during the inspiral phase. It can approximately assess the detectability of individual sources by LISA, and compute the background due to unresolved sources in the LISA band using different methods. The simulated populations can be saved in a format compatible with LISA LDC.

The current BBH models are based on arXiv:2111.03634 and references therein, and the implementation is based on work in collaboration with Stanislav Babak, Chiara Caprini, Daniel Figueroa, Nikolaos Karnesis, Paolo Marcoccia, Germano Nardini, Mauro Pieroni, Angelo Ricciardone and Alberto Sesana.

Simulations are well calibrated to produce accurate background calculations and fair random generation at the tails of the distributions (important for accurate probability of detectable events). This code uses a number of ad-hoc techniques for rapid simulation (O(1min) for large LISA-relevant populations). There is a lot of room for further optimisation, up to almost 1 order of magnitude, if required (please, get in touch).

FRIDDA is a Python code that allows forecasts, based on Fisher Matrix Analysis techniques and for various fiducial cosmological models, of the cosmological impact of measurements of the redshift drift and the fine-structure constant (alpha) as well as their combination. It is designed for the ArmazoNes high Dispersion Echelle Spectrograph (ANDES), but it is easily adaptable to other fiducial cosmological models and to other instruments with similar scientific goals.

World Observatory visualizes S/N-versus-cost tradeoffs for large optical/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 - giving a universal metric.

naif is a pure-python package based on the Numerical Analysis of Fundamental Frequencies (NAFF) algorithm, first proposed by Laskar (1990) and further developed by Valluri & Merritt (1998). Given a time-series, particularly that of an orbital coordinate, it extracts from its power-spectrum as many frequencies and respective amplitudes as required. In comparison to the original NAFF algorithm, it has some improvements, particularly in the performance (computation time). It also offers functions to plot the power-spectrum before extraction of each frequency, which can be useful for debugging particular orbits. The code is fully documented and the documentation page has several tutorials. In the future, the code will be expanded with other tools for frequency analysis.

CosmosCanvas is a library for creating perception-based colour 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.