ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:1502.020] ketu: Exoplanet candidate search code

ketu, written in Python, searches K2 light curves for evidence of exoplanets; the code simultaneously fits for systematic effects caused by small (few-pixel) drifts in the telescope pointing and other spacecraft issues and the transit signals of interest. Though more computationally expensive than standard search algorithms, it can be efficiently implemented and used to discover transit signals.

[ascl:1708.021] KERTAP: Strong lensing effects of Kerr black holes

KERTAP computes the strong lensing effects of Kerr black holes, including the effects on polarization. The key ingredients of KERTAP are a graphic user interface, a backward ray-tracing algorithm, a polarization propagator dealing with gravitational Faraday rotation, and algorithms computing observables such as flux magnification and polarization angles.

[ascl:2305.012] KERN: Radio telescope toolkit

KERN contains most of the standard tools needed to work with radio telescope data. The suite saves time and reduces frustration in setting up of scientific pipelines, and also improves scientific reproducibility. It includes a wide variety of packages, including 21cmfast (ascl:1102.023), BRATS (ascl:1806.025), CARTA (ascl:2103.031), casacore (ascl:1912.002), CubiCal (ascl:1805.031), DDFacet (ascl:2305.008), PyBDSF (ascl:1502.007),TiRiFiC (ascl:1208.008), WSClean (ascl:1408.023), and many others. KERN can be run on a supported platform such as Ubuntu, with Docker and Singularity, or in a virtual machine.

[ascl:1806.022] Keras: The Python Deep Learning library

Keras is a high-level neural networks API written in Python and capable of running on top of TensorFlow, CNTK, or Theano. It focuses on enabling fast experimentation.

[ascl:1706.012] KeplerSolver: Kepler equation solver

KeplerSolver solves Kepler's equation for arbitrary epoch and eccentricity, using continued fractions. It is written in C and its speed is nearly the same as the SWIFT routines, while achieving machine precision. It comes with a test program to demonstrate usage.

[ascl:2107.027] KeplerPORTS: Kepler Planet Occurrence Rate Tools

KeplerPORTS calculates the detection efficiency of the DR25 Kepler Pipeline. It uses a detection contour model to quantify the recoverability of transiting planet signals due to the Kepler pipeline, and accurately portrays the ability of the Kepler pipeline to generate a Threshold Crossing Event (TCE) for a given hypothetical planet.

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

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

[ascl:2105.021] Kepler's Goat Herd: Solving Kepler's equation via contour integration

Kepler's Goat Herd solves Kepler's equation using contour integration to solve the "geometric goat problem". The C++ code implements a variety of solution: 1.) Newton-Raphson: The quadratic Newton-Raphson root finder; 2.) Danby: The quartic root; 3.) Series: An elliptical series method; and 4.) Contour: A new method based on contour integration. Given an array of mean anomalies, an eccentricity and a desired precision, the code estimates the eccentric anomaly using each method. The accuracy of each approach is increased until the desired precision is reached, and timing is performed using the C++ chrono package.

[ascl:1702.007] KEPLER: General purpose 1D multizone hydrodynamics code

KEPLER is a general purpose stellar evolution/explosion code that incorporates implicit hydrodynamics and a detailed treatment of nuclear burning processes. It has been used to study the complete evolution of massive and supermassive stars, all major classes of supernovae, hydrostatic and explosive nucleosynthesis, and x- and gamma-ray bursts on neutron stars and white dwarfs.

[ascl:1712.001] KDUtils: Kinematic Distance Utilities

The Kinematic Distance utilities (KDUtils) calculate kinematic distances and kinematic distance uncertainties. The package includes methods to calculate "traditional" kinematic distances as well as a Monte Carlo method to calculate kinematic distances and uncertainties.

[ascl:2301.018] kderp: Keck Cosmic Web Imager Data Extraction and Reduction Pipeline in IDL

kderp (KCWI Data Extraction and Reduction Pipeline) reduces data for the Keck Cosmic Web Imager. Written in IDL, it performs basic CCD reduction on raw images to produce bias and overscan subtracted, gain-corrected, trimmed and cosmic ray removed images; it can also subtract the sky. It defines the geometric transformations required to map each pixel in the 2d image into slice, postion, and wavelength, and performs flat field and illumination corrections. It generates cubes, applying the transformations previously solved to the object intensity, variance and mask images output from any of the previous stages, and uses a standard star observation to generate an inverse sensitivity curve which is applied to the corresponding observations to flux calibrate them.

This pipeline has been superseded by KCWI_DRP (ascl:2301.019).

[ascl:2107.022] Kd-match: Correspondences of objects between two catalogs through pattern matching

Kd-match matches stellar catalogs for which the transformation between the coordinate systems of the two catalogs is unknown and might include shearing. The code uses the ratio of sides as the invariant under a coordinate transformation and searches for several triangles with similar transformations by building quadrilaterals from sets of four objects in each catalog and calculating the ratio of areas of the triangles that comprise the quadrilaterals. The k-d tree accelerates this quadrilateral search dramatically and is significantly faster than the customary direct search over triangles.

[submitted] KCWIKit: KCWI Post-Processing and Improvements

KCWIKit extends the official KCWI DRP with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.

[ascl:2301.019] KCWI_DRP: Keck Cosmic Web Imager Data Reduction Pipeline in Python

KCWI_DRP, written in Python and based on kderp (ascl:2301.018), is the official DRP for the Keck Cosmic Web Imager at the W. M. Keck Observatory. It provides all of the functionality of the older pipeline and has three execution modes: multi-threading for CPU intensive tasks such as wavelength calibration, and multi-processing for large datasets. It offers vacuum to air and heliocentric or barycentric correction and the ability to use KOA file names or original file names. KCWI_DRP also improves the provenance and traceability of DRP versions and execution steps in the headers over kderp, and has versatile sky subtraction modes including using external sky frames and ability of masking regions.

[ascl:1701.010] kcorrect: Calculate K-corrections between observed and desired bandpasses

kcorrect fits very restricted spectral energy distribution models to galaxy photometry or spectra in the restframe UV, optical and near-infrared. The main purpose of the fits are for calculating K-corrections. The templates used for the fits may also be interpreted physically, since they are based on the Bruzual-Charlot stellar evolution synthesis codes. Thus, for each fit galaxy kcorrect can provide an estimate of the stellar mass-to-light ratio.

[ascl:2211.002] KC: Analytical propagator with collision detection for Keplerian systems

The analytic propagator Kepler-Collisions calculates collisions for Keplerian systems. The algorithm maintains a list of collision possibilities and jumps from one collision to the next; since collisions are rare in astronomical scales, jumping from collision to collision and calculating each one is more efficient than calculating all the time steps that are between collisions.

[ascl:1701.005] KAULAKYS: Inelastic collisions between hydrogen atoms and Rydberg atoms

KAULAKYS calculates cross sections and rate coefficients for inelastic collisions between Rydberg atoms and hydrogen atoms according to the free electron model of Kaulakys (1986, 1991). It is written in IDL and requires the code MSWAVEF (ascl:1701.006) to calculate momentum-space wavefunctions. KAULAKYS can be easily adapted to collisions with perturbers other than hydrogen atoms by providing the appropriate scattering amplitudes.

[ascl:2106.026] Katu: Interaction of particles in plasma simulator

Katu evolves the interaction of particles (photons, protons, neutrons, leptons, pions and neutrinos) in plasma. The package comes with wrappers for emcee (ascl:1303.002) and pymultinest (ascl:1606.005) for Bayesian analysis, making the software applicable to blazars and able to extract relevant statistical information from their electromagnetic (and neutrino, if applicable) flux. The code is optimized for fast performance, and can be easily modified and extended.

[ascl:2305.004] katdal: MeerKAT Data Access Library

katdal interacts with the chunk stores and HDF5 files produced by the MeerKAT radio telescope and its predecessors (KAT-7 and Fringe Finder), which are collectively known as MeerKAT Visibility Format (MVF) data sets. The library uses memory carefully, allowing data sets to be inspected and partially loaded into memory. Data sets may be concatenated and split via a flexible selection mechanism. In addition, katdal provides a script to convert these data sets to CASA MeasurementSets.

[ascl:2209.006] KaRMMa: Curved-sky mass map reconstruction

KaRMMa (Kappa Reconstruction for Mass MApping) performs curved-sky mass map reconstruction using a lognormal prior from weak-lensing surveys. It uses a fully Bayesian approach with a physically motivated lognormal prior to sample from the posterior distribution of convergence maps. The posterior distribution of KaRMMa maps are nearly unbiased in one-point and two-point functions and peak/void counts. KaRMMa successfully captures the non-Gaussian nature of the distribution of κ values in the simulated maps, and KaRMMa posteriors correctly characterize the uncertainty in summary statistics.

[ascl:1102.018] Karma: Visualisation Test-Bed Toolkit

Karma is a toolkit for interprocess communications, authentication, encryption, graphics display, user interface and manipulating the Karma network data structure. It contains KarmaLib (the structured libraries and API) and a large number of modules (applications) to perform many standard tasks. A suite of visualisation tools are distributed with the library.

[ascl:1611.010] Kapteyn Package: Tools for developing astronomical applications

The Kapteyn Package provides tools for the development of astronomical applications with Python. It handles spatial and spectral coordinates, WCS projections and transformations between different sky systems; spectral translations (e.g., between frequencies and velocities) and mixed coordinates are also supported. Kapteyn offers versatile tools for writing small and dedicated applications for the inspection of FITS headers, the extraction and display of (FITS) data, interactive inspection of this data (color editing) and for the creation of plots with world coordinate information. It includes utilities for use with matplotlib such as obtaining coordinate information from plots, interactively modifiable colormaps and timer events (module mplutil); tools for parsing and interpreting coordinate information entered by the user (module positions); a function to search for gaussian components in a profile (module profiles); and a class for non-linear least squares fitting (module kmpfit).

[ascl:1502.008] KAPPA: Optically thin spectra synthesis for non-Maxwellian kappa-distributions

Based on the freely available CHIANTI (ascl:9911.004) database and software, KAPPA synthesizes line and continuum spectra from the optically thin spectra that arise from collisionally dominated astrophysical plasmas that are the result of non-Maxwellian κ-distributions detected in the solar transition region and flares. Ionization and recombination rates together with the ionization equilibria are provided for a range of κ values. Distribution-averaged collision strengths for excitation are obtained by an approximate method for all transitions in all ions available within CHIANTI; KAPPA also offers tools for calculating synthetic line and continuum intensities.

[ascl:1403.022] KAPPA: Kernel Applications Package

KAPPA comprising about 180 general-purpose commands for image processing, data visualization, and manipulation of the standard Starlink data format--the NDF. It works with Starlink's various specialized packages; in addition to the NDF, KAPPA can also process data in other formats by using the "on-the-fly" conversion scheme. Many commands can process data arrays of arbitrary dimension, and others work on both spectra and images. KAPPA operates from both the UNIX C-shell and the ICL command language. KAPPA uses the Starlink environment (ascl:1110.012).

[ascl:1906.005] Kalman: Forecasts and interpolations for ALMA calibrator variability

Kalman models an inhomogeneous time series of measurements at different frequencies as noisy sampling from a finite mixture of Gaussian Ornstein-Uhlenbeck processes to try to reproduce the variability of the fluxes and of the spectral indices of the quasars used as calibrators in the Atacama Large Millimeter/Sub-millimeter Array (ALMA), assuming sensible parameters are provided to the model (obtained, for example, from maximum likelihood estimation). One routine in the Kalman Perl module calculates best forecast estimations based on a state space representation of the stochastic model using Kalman recursions, and another routine calculates the smoothed estimation (or interpolations) of the measurements and of the state space also using Kalman recursions. The code does not include optimization routines to calculate best fit parameters for the stochastic processes.

[ascl:2011.003] Kalkayotl: Inferring distances to stellar clusters from Gaia parallaxes

Kalkayotl obtains samples of the joint posterior distribution of cluster parameters and distances to the cluster stars from Gaia parallaxes using Bayesian inference. The code is designed to deal with the parallax spatial correlations of Gaia data, and can accommodate different values of parallax zero point and spatial correlation functions.

[ascl:1607.013] Kālī: Time series data modeler

The fully parallelized and vectorized software package Kālī models time series data using various stochastic processes such as continuous-time ARMA (C-ARMA) processes and uses Bayesian Markov Chain Monte-Carlo (MCMC) for inferencing a stochastic light curve. Kālī is written in c++ with Python language bindings for ease of use. Kālī is named jointly after the Hindu goddess of time, change, and power and also as an acronym for KArma LIbrary.

[ascl:1803.005] Kadenza: Kepler/K2 Raw Cadence Data Reader

Kadenza enables time-critical data analyses to be carried out using NASA's Kepler Space Telescope. It enables users to convert Kepler's raw data files into user-friendly Target Pixel Files upon downlink from the spacecraft. The primary motivation for this tool is to enable the microlensing, supernova, and exoplanet communities to create quicklook lightcurves for transient events which require rapid follow-up.

[ascl:2106.013] Kadath: Spectral solver

The Kadath library implements spectral methods in the context of theoretical physics. It is fully parallel; a sequential version can be installed. The library is written in C++, and solves a wide variety of problems. Several coordinates systems are implemented and additional geometries can be easily encoded. Partial differential equations of various types are discretized by means of spectral methods. The resulting system is solved using a Newton-Raphson iteration, allowing KADATH to deal with strongly non-linear situations. An optimized version of Kadath is available that improves memory management (reducing the number of uses of new and delete), inlines several member functions, and provides better management of the accessors for the arrays.

[ascl:1307.003] K3Match: Point matching in 3D space

K3Match is a C library with Python bindings for fast matching of points in 3D space. It uses an implementation of three dimensional binary trees to efficiently find matches between points in 3D space. Two lists of points are compared and match indices as well as distances are given. K3Match can find either the nearest neighbour or all matches within a given search distance in 3D Cartesian space or on the surface of the 2D unit sphere in standard spherical or celestial coordinates.

[ascl:1605.012] K2SC: K2 Systematics Correction

K2SC (K2 Systematics Correction) models instrumental systematics and astrophysical variability in light curves from the K2 mission. It enables the user to remove both position-dependent systematics and time-dependent variability (e.g., for transit searches) or to remove systematics while preserving variability (for variability studies). K2SC automatically computes estimates of the period, amplitude and evolution timescale of the variability for periodic variables and can be run on ASCII and FITS light curve files. Written in Python, this pipeline requires NumPy, SciPy, MPI4Py, Astropy (ascl:1304.002), and George (ascl:1511.015).

[ascl:1607.010] K2PS: K2 Planet search

K2PS is an Oxford K2 planet search pipeline. Written in Python, it searches for transit-like signals from the k2sc-detrended light curves.

[ascl:1602.014] k2photometry: Read, reduce and detrend K2 photometry

k2photometry reads, reduces and detrends K2 photometry and searches for transiting planets. MAST database pixel files are used as input; the output includes raw lightcurves, detrended lightcurves and a transit search can be performed as well. Stellar variability is not typically well-preserved but parameters can be tweaked to change that. The BLS algorithm used to detect periodic events is a Python implementation by Ruth Angus and Dan Foreman-Mackey (https://github.com/dfm/python-bls).

[ascl:2107.026] K2mosaic: Mosaic Kepler pixel data

K2mosaic stitches the postage stamp-sized pixel masks obtained by NASA's Kepler and K2 missions together into CCD-sized mosaics and movies. The command-line tool's principal use is to take a set of Target Pixel Files (TPF) and turn them into more traditional FITS image files -- one per CCD channel and per cadence. K2mosaic can also be used to create animations from these mosaics. The mosaics produced by K2mosaic also makes the analysis of certain Kepler/K2 targets, such as clusters and asteroids, easier. Moreover such mosaics are useful to reveal the context of single-star observations, e.g., they enable users to check for the presence of instrumental noise or nearby bright objects.

[ascl:1601.009] K2fov: Field of view software for NASA's K2 mission

K2fov allows users to transform celestial coordinates into K2's pixel coordinate system for the purpose of preparing target proposals and field of view visualizations. In particular, the package, written in Python, adds the "K2onSilicon" and "K2findCampaigns" tools to the command line, allowing the visibility of targets to be checked in a user-friendly way.

[ascl:1503.001] K2flix: Kepler pixel data visualizer

K2flix makes it easy to inspect the CCD pixel data obtained by NASA's Kepler space telescope. The two-wheeled extended Kepler mission, K2, is affected by new sources of systematics, including pointing jitter and foreground asteroids, that are easier to spot by eye than by algorithm. The code takes Kepler's Target Pixel Files (TPF) as input and turns them into contrast-stretched animated gifs or MPEG-4 movies. K2flix can be used both as a command-line tool or using its Python API.

[submitted] K2CE: Kepler-K2 Cadence Events

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 .

[ascl:2107.024] K2-CPM: Causal Pixel Model for K2 data

K2-CPM captures variability while preserving transit signals in Kepler data. Working at the pixel level, the model captures very fine-grained information about the variation of the spacecraft. The CPM models the systematic effects in the time series of a pixel using the pixels of many other stars and the assumption that any shared signal in these causally disconnected light curves is caused by instrumental effects. The target star's future and past are used and the data points are separated into training and test sets to ensure that information about any transit is perfectly isolated from the model. The method has four tuning parameters, the number of predictor stars or pixels, the autoregressive window size, and two L2-regularization amplitudes for model components, and consistently produces low-noise light curves.

[ascl:1507.013] K-Inpainting: Inpainting for Kepler

Inpainting is a technique for dealing with gaps in time series data, as frequently occurs in asteroseismology data, that may generate spurious peaks in the power spectrum, thus limiting the analysis of the data. The inpainting method, based on a sparsity prior, judiciously fills in gaps in the data, preserving the asteroseismic signal as far as possible. This method can be applied both on ground and space-based data. The inpainting technique improves the oscillation modes detection and estimation, the impact of the observational window function is reduced, and the interpretation of the power spectrum is simplified. K-Inpainting can be used to study very long time series of many stars because its computation is very fast.

[ascl:2110.001] JWSTSim: Geometric-Focused JWST Deep Field Image Simulation

JWST_Simulation generates a novel geometric-focused deep field simulation of the expected JWST future deep field image. Galaxies are represented by ellipses with randomly-generated positions and orientations. Three scripts are included: a deterministic simulation, an ensemble simulation, and a more-realistic monochrome image simulation. The following initial conditions can be perturbed in these codes: H0, Ωm, ΩΛ, the dark energy equation of state parameter, the number of unseen galaxies in the Hubble Ultra Deep Field Image (HUDF), the increase in effective radius due to the JWST’s higher sensitivity, the anisotropy of dark energy, and the maximum redshift reached by the JWST. Galaxy number densities are estimated using integration over comoving volume with an integration constant calibrated with the Hubble Ultra Deep Field. A galaxy coverage percentage is calculated for each image to determine the percentage of the background occupied by galaxies.

[ascl:1504.017] JWFront: Wavefronts and Light Cones for Kerr Spacetimes

JWFront visualizes wavefronts and light cones in general relativity. The interactive front-end allows users to enter the initial position values and choose the values for mass and angular momentum per unit mass. The wavefront animations are available in 2D and 3D; the light cones are visualized using the coordinate systems (t, x, y) or (t, z, x). JWFront can be easily modified to simulate wavefronts and light cones for other spacetime by providing the Christoffel symbols in the program.

[ascl:1904.029] JVarStar: Variable Star Analysis Library

JVarStar (Java Variable Star Analysis) performs pattern classification by analyzing variable star data. This all-in-one library package includes machine learning techniques, fundamental mathematical methods, and digital signal processing functions that can be externally referenced (i.e., from Python), or can be used for further Java development. This library has dependencies on several open source packages that, along with the developed functionality, provides a developer with an easily accessible library from which to construct stable variable star analysis and classification code.

[ascl:1702.003] juwvid: Julia code for time-frequency analysis

Juwvid performs time-frequency analysis. Written in Julia, it uses a modified version of the Wigner distribution, the pseudo Wigner distribution, and the short-time Fourier transform from MATLAB GPL programs, tftb-0.2. The modification includes the zero-padding FFT, the non-uniform FFT, the adaptive algorithm by Stankovic, Dakovic, Thayaparan 2013, the S-method, the L-Wigner distribution, and the polynomial Wigner-Ville distribution.

[ascl:1109.024] Jupiter: Multidimensional Astrophysical Hydrocode

Jupiter is a multidimensional astrophysical hydrocode. It is based on a Godunov method, and it is parallelized with MPI. The mesh geometry can either be cartesian, cylindrical or spherical. It allows mesh refinement and includes special features adapted to the description of planets embedded in disks and nearly steady states.

[ascl:1812.016] Juliet: Transiting and non-transiting exoplanetary systems modelling tool

Juliet essentially serves as a wrapper of other tools, including Batman (ascl:1510.002), George (ascl:1511.015), Dynesty (ascl:1809.013) and AstroPy (ascl:1304.002), to analyze and model transits, radial-velocities, or both from multiple instruments at the same time. Using nested sampling algorithms, it performs a thorough sampling of the parameter space and a model comparison via Bayesian evidences. Juliet also fits transiting and non-transiting multi-planetary systems, and Gaussian Processes (GPs) which might share hyperparameters between the photometry and radial-velocities simultaneously (e.g., stellar rotation periods).

[ascl:1607.007] JUDE: An Utraviolet Imaging Telescope pipeline

JUDE (Jayant's UVIT Data Explorer) converts the Level 1 data (FITS binary table) from the Ultraviolet Imaging Telescope (UVIT) on ASTROSAT into three output files: a photon event list as a function of frame number (FITS binary table); a FITS image file with two extensions; and a PNG file created from the FITS image file with an automated scaling.

[ascl:1511.002] JSPAM: Interacting galaxies modeller

JSPAM models galaxy collisions using a restricted n-body approach to speed up computation. Instead of using a softened point-mass potential, the software supports a modified version of the three component potential created by Hernquist (1994, ApJS 86, 389). Although spherically symmetric gravitationally potentials and a Gaussian model for the bulge are used to increase computational efficiency, the potential mimics that of a fully consistent n-body model of a galaxy. Dynamical friction has been implemented in the code to improve the accuracy of close approaches between galaxies. Simulations using this code using thousands of particles over the typical interaction times of a galaxy interaction take a few seconds on modern desktop workstations, making it ideal for rapidly prototyping the dynamics of colliding galaxies. Extensive testing of the code has shown that it produces nearly identical tidal features to those from hierarchical tree codes such as Gadget but using a fraction of the computational resources. This code was used in the Galaxy Zoo: Mergers project and is very well suited for automated fitting of galaxy mergers with automated pattern fitting approaches such as genetic algorithms. Java and Fortran versions of the code are available.

[ascl:1908.017] JPLephem: Jet Propulsion Lab ephemerides package

JPLephem loads and uses standard Jet Propulsion Laboratory (JPL) ephemerides for predicting the position and velocity of a planet or other Solar System body. It is one of the foundations of the Skyfield (ascl:1907.024) astronomy library for Python, and can also be used as a standalone package to generate raw vectors.

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

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

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

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

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

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

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

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

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

[ascl:2006.013] JoXSZ: Joint X-ray and SZ fitting for galaxy clusters in Python

JoXSZ jointly fits the thermodynamic profiles of galaxy clusters from both SZ and X-ray data using a Markov chain Monte Carlo fitting algorithm. It is an enhanced version of preprofit (ascl:1910.002), which fits only SZ data. JoXSZ parameterizes the pressure and electron density profile of a galaxy cluster with a given center and derives the temperature profile as the ratio of these quantities through the ideal gas law. The X-ray and SZ-based temperatures can be similar or different, which allows study of the cluster elongation along line of sight, gas clumping, or calibration uncertainties.

Would you like to view a random code?