Results 51-100 of 2223 (2184 ASCL, 39 submitted)
Cobra uses single pulse time series data to search for and time pulsars, performing a fully phase coherent timing analysis. The GPU-accelerated Bayesian analysis package, written in Python, incorporates models for both isolated and accelerated systems, as well as both Keplerian and relativistic binaries. Cobra builds a model pulse train that incorporates effects such as aliasing, scattering and binary motion and a simple Gaussian profile and compares this directly to the data; the software can thus combine data over multiple frequencies, epochs, or even across telescopes.
GizmoAnalysis reads and analyzes N-body simulations run with the Gizmo code (ascl:1410.003). Written in Python, it was developed primarily to analyze FIRE simulations, though it is usable with any Gizmo snapshot files. It offers the following functionality: reads snapshot files and converts particle data to physical units; provides a flexible dictionary class to store particle data and compute derived quantities on the fly; plots images and properties of particles; and generates region files for input to MUSIC (ascl:1311.011) to generate cosmological zoom-in initial conditions. GizmoAnalysis also computes rates of supernovae and stellar winds, including their nucleosynthetic yields, as used in FIRE simulations. The software package includes a tutorial in a Jupyter notebook.
HaloAnalysis reads and analyzes halo/galaxy catalogs, generated from Rockstar (ascl:1210.008) or AHF (ascl:1102.009), and merger trees generated from Consistent Trees (ascl:1210.011). Written in Python, it offers the following functionalities: reads halo/galaxy/tree catalogs from multiple file formats; assigns baryonic particles and galaxy properties to dark-matter halos; combines and re-generates halo/galaxy/tree files in hdf5 format; analyzes properties of halos/galaxies; and selects halos to generate zoom-in initial conditions. The code includes a tutorial in the form of a Jupyter notebook.
GWecc computes the pulsar timing array (PTA) signals induced by eccentric supermassive binaries. Written in C++, it computes the plus/cross polarizations as well as Earth and pulsar terms of the PTA signal given the binary parameters and the sky locations of the binary and the pulsar. A python wrapper is included through which GWecc can be used to simulate, search for and constrain gravitational wave-emitting eccentric supermassive binaries using packages such as ENTERPRISE (ascl:1912.015) and libstempo (ascl:2002.017).
DMRadon calculates the Radon Transform for use in the analysis of Directional Dark Matter Direct Detection. The code can calculate speed distributions, velocity distribution, velocity integral (eta) and Radon Transforms or a standard Maxwell-Boltzmann distribution. DMRadon also calculates the velocity distribution averaged over different angular bins.
PyHammer performs rapid and automatic spectral classification of stars according to the Morgan-Keenan classification system; it is a Python revision of the IDL code The Hammer (ascl:1405.003) and offers additional capabilities. Working in the range of 3,650-10,200 Angstroms, the automatic spectral typing algorithm compares important spectral lines to template spectra and determines the best matching spectral type, ranging from O to L type stars. The code can also determine a star's metallicity ([Fe/H]) and radial velocity shifts. Once the automatic classification algorithm has run, PyHammer provides the user an interface for determining spectral types visually by comparing their spectra to provided templates.
Apercal is a dedicated, automated data reduction and analysis pipeline written for the Apertif (APERture Tile In Focus) upgrade to the Westerbork Synthesis Radio Telescope. This upgrade dramatically increases the field of view and survey speed of the telescope and is being used for survey observations that can produce 5 terabytes of data for each observation. Apercal uses existing and new tools and parallelization to provide the performance needed for the large volume of data produced Apertif surveys. The software is written entirely in Python and uses third–party astronomical software, such as AOFlagger (ascl:1010.017), CASA (ascl:1107.013), and Miriad (ascl:1106.007), for certain tasks. Apercal is modular, making it possible to run specific modules manually instead of the full pipeline, and information can be exchanged between modules because status parameters are written and read from a python pickled dictionary file. The pipeline can also run fully automatically.
DASH classifies the type, age, redshift and host for any supernova spectra based on the learned features, through use of a deep convolutional neural network to train a matching algorithm, of each supernova’s type and age. The Python library allows a user to classify spectra; the software is fast and can classify thousands of spectra in seconds. A graphical interface that enables a user to view and classify a spectrum is also available.
ExoSim models host star and planet transit events, simulating the temporal change in stellar flux due to the light curve. It is wavelength-dependent, using an input planet spectrum to determine the light curve depth for any given wavelength and can capture temporal effects, such as correlated noise. ExoSim's star spot simulator produces simulated observations that include spot and facula contamination. The code is flexible and can be generically applied to different instruments that simulate specific time-dependent processes.
ProSpect generates good quality SEDs that can be used to estimate the broad band photometric properties of galaxies that have known star formation and gas metallicity histories. It allows for complex star formation and metallicity histories to be specified, and can be used in a generative or fitting (Bayesian) mode. ProSpect provides a high level interface to the BC03 (low and high resolution) and EMILES libraries, as well as the Dale 2014 dust emission templates. Its source code is available for download, and it is also available as an interactive web tool.
ScamPy "paints" an observed population of cosmological objects on top of the DM-halo/subhalo hierarchy obtained from DM-only simulations. The method combines the Halo Occupation Distribution (HOD) method with sub-halo abundance matching (SHAM); the two processes together are dubbed Sub-halo clustering and abundance matching (SCAM). The procedure requires applying the two methods in sequence; by applying the HOD scheme, the host sub-haloes are selected, and the SHAM algorithm associates an observable property of choice to each sub-halo. The provided python interface allows users to load and populate DM halos and sub-halos obtained by FoF and SUBFIND algorithms applied to DM snapshots at any redshift. The software is highly-optimized and flexible.
ODUSSEAS (Observing Dwarfs Using Stellar Spectroscopic Energy-Absorption Shapes) uses machine learning to derive the Teff and [Fe/H] of M dwarf stars by using their optical spectra obtained by different spectrographs with different resolutions. The software uses the measurement of the pseudo equivalent widths for more than 4000 stellar absorption lines and the machine learning Python package scikit-learn (https://scikit-learn.org/stable/) to predict the stellar parameters.
triceratops (Tool for Rating Interesting Candidate Exoplanets and Reliability Analysis of Transits Originating from Proximate Stars) validates planet candidates from the Transiting Exoplanet Survey Satellite (TESS). The code calculates the probabilities of a wide range of transit-producing scenarios using the primary transit of the planet candidate and preexisting knowledge of its host and nearby stars. It then uses the known properties of these stars to calculate star-specific priors for each scenario with estimates of stellar multiplicity and planet occurrence rates.
ORIGIN performs blind detection of faint emitters in MUSE datacubes. The algorithm is tuned to detect faint spatial-spectral emission signatures while allowing for a stable false detection rate over the data cube, and providing in the same time an automated and reliable estimation of the purity. ORIGIN implements a nuisance removal part based on a continuum subtraction combining a Discrete Cosine Transform and an iterative Principal Component Analysis and a detection part based on the local maxima of Generalized Likelihood Ratio test statistics obtained for a set of spatial-spectral profiles of emission line emitters. In addition, it performs a purity estimation in which the proportion of true emission lines is estimated from the data itself: the distribution of the local maxima in the noise only configuration is estimated from that of the local minima.
The massively parallel code RASCAS (RAdiative SCattering in Astrophysical Simulations) performs radiative transfer on an adaptive mesh with an octree structure using the Monte Carlo technique. The code features full MPI parallelization, domain decomposition, adaptive load-balancing, and a standard peeling algorithm to construct mock observations. The radiative transport of resonant line photons through different mixes of species (e.g. HI, SiII, MgII, FeII), including their interaction with dust, is implemented in a modular fashion to allow new transitions to be easily added to the code. RASCAS may also be used to propagate photons at any wavelength (e.g. stellar continuum or fluorescent lines), and has been designed to be easily customizable and to process simulations of arbitrarily large sizes on large supercomputers.
SDAR (Slow-Down Algorithmic Regularization) simulates the long-term evolution of few-body systems such as binaries and triples. The algorithm used provides a few orders of magnitude faster performance than the classical N-body method. The secular evolution of hierarchical systems, e.g. Kozai-Lidov oscillation, can be well reproduced. The code is written in the C++ language and can be used either as a stand-alone tool or a library to be plugged in other N-body codes. The high precision of the floating point to 62 digits is also supported.
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.
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 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.
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.
gnm is an implementation of the affine-invariant sampler for Markov chain Monte Carlo (MCMC) that uses the Gauss-Newton-Metropolis (GNM) Algorithm. The GNM algorithm is specialized in sampling highly non-linear posterior probability distribution functions of the form exp(-||f(x)||^2/2). The code includes dynamic hyper-parameter optimization to increase performance of the sampling; other features include the Jacobian tester and an error bars creator.
The NVIDIA GPU-based pipeline code peasoup provides a one-step pulsar search, including searching for pulsars with up to moderate accelerations, with only one command. Its features include dedispersion, dereddening in the Fourier domain, resampling, peak detection, and optional time series folding. peasoup's output is the candidate list.
RPPPS (Re-analysing Pipeline for Parkes Pulsar Survey) uses Linux shell scripts, C language, and python code and two parallel strategies to reorganize the PRESTO (ascl:1107.017) pulsar search pipeline to run multiple processes in parallel, thus accelerating the search for pulsars. Though originally designed for reprocessing PMPS data, the code has also been successfully used with FAST (Five-hundred-meter Aperture Spherical radio Telescope) drift scan data. The pipeline is only CPU-based and can be easily and quickly deployed in computing nodes for testing purposes or data processes.
MCMCI (Markov chain Monte Carlo + isochrones) characterizes a whole exoplanetary system directly by modeling the star and its planets simultaneously. The code, written in Fortran, uses light curves and basic stellar parameters with a transit analysis algorithm that interacts with stellar evolutionary models, thus using both model-dependent and empirical age indicators to characterize the system.
ExoTETHyS models exoplanetary transits, eclipsing binaries, and related phenomena. The package calculates stellar limb-darkening coefficients down to <10 parts per million (ppm) and generates an exact transit light-curve based on the entire stellar intensity profile rather than limb-darkening coefficients.
CosMOPED (Cosmological MOPED) uses the MOPED (Multiple/Massively Optimised Parameter Estimation and Data compression) compression scheme to compress the Planck power spectrum. This convenient and lightweight compressed likelihood code is implemented in Python. To compute the likelihood for the LambdaCDM model using CosMOPED, one needs only six compression vectors, one for each parameter, and six numbers from compressing the Planck data using the six compression vectors. Using these, the likelihood of a theory power spectrum given the Planck data is the product of six one-dimensional Gaussians. Extended cosmological models require computing extra compression vectors.
ORCS (Outils de Réduction de Cubes Spectraux) is an analysis engine for SITELLE spectral cubes. The software extracts integrated spectra, fits the sinc emission lines, and recalibrates data in wavelength, astrometry and flux. ORCS offers a choice between a Bayesian or a classical fitting algorithm , and also provides automatic source detection and radial velocity correction.
DebrisDiskFM provides forward modeling for circumstellar debris disks in scattered light using the MCFOST disk modeling software to generate disk model images using given input parameters and emcee (ascl:1303.002) to obtain the posterior distributions for these parameters.
Behind The Spectrum (BTS) is a fully-automated multiple-component fitter for optically-thin spectra. Written as a python module, the routine uses the first, second and third derivatives to determine thenumber of components in the spectrum. A least-squared fitting routine then determines the best fit with that number of components, checking for over-fitting and over-lapping velocity centroids.
Protostellar Evolution simulates the evolution of stellar stellar radius and luminosity from the bound core stage through to the core hydrogen ignition as a zero-age main-sequence (ZAMS) star and beyond. Written in Fortran 90, the code is implemented as a module of the FLASH astrophysical fluid dynamics code (ascl:1010.082).
The CASA (1107.013) task FAKEOBS generates model visibilities from already-existing measurement sets. This task can be used to substitute all the visibilities of the target with simulations computed from any model image. The measurement can either be with real or simulated data, the target can have been observed in mosaic mode, and there can be several sources (e.g., bandpass calibrator, flux/phase calibrator, and target).
FragMent studies fragmentation in filaments by collating a number of different techniques, including nearest neighbour separations, minimum spanning tree, two-point correlation function, and Fourier power spectrum. It also performs model selection using a frequentist and Bayesian approach to find the best descriptor of a filament's fragmentation. While the code was designed to investigate filament fragmentation, the functions are general and may be used for any set of 2D points to study more general cases of fragmentation.
sf3dmodels models star-forming regions; it brings together analytical models in order to compute their physical properties in a 3-dimensional grid. The package can couple different models in a single grid to recreate complex star forming systems such as those being revealed by current instruments. The output data can be read with LIME (ascl:1107.012) or RADMC-3D (ascl:1108.016) to carry out radiative transfer calculations of the modeled region.
TRANSPHERE is a simple dust continuum radiative transfer code for spherically symmetric circumstellar envelopes. It handles absorption and re-emission and computes the dust temperature self-consistently; it does not, however, deal with scattering. TRANSPHERE uses a variable eddington factor method for the radiative transfer. The RADMD code (ascl:1108.016) is more versatile, but for a spherically symmetric problem for which scattering is of much concern, it may be easier to use a simple code such as TRANSPHERE.
Please note that this code has not been updated since 2006.
Min-CaLM performs automated mineral compositional analysis on debris disk spectra. The user inputs the debris disk spectrum, and using Min-CaLM's built-in mineralogical library, Min-CaLM calculates the relative mineral abundances within the disk. To do this calculation, Min-CaLM converts the debris disk spectrum and the mineralogical library spectra into a system of linear equations, which it then solves using non-negative least square minimization. This code comes with a GitHub tutorial on how to use the Min-CaLM package.
amber_meta integrates a few routines to launch AMBER (the “Apertif Monitor for Bursts Encountered in Real-time”, https://github.com/AA-ALERT/AMBER) 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.
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.
JetSeT is an open source C/Python framework to reproduce radiative and accelerative processes acting in relativistic jets, allowing to fit the numerical models to observed data. The main features of this framework are:
- Handling observed data: re-binning, definition of data sets, bindings to astropy tables and quantities
definition of complex numerical radiative scenarios: Synchrotron Self-Compton (SSC), external Compton
(EC) and EC against the CMB
- Constraining of the model in the pre-fitting stage, based on accurate and already published
phenomenological trends. In particular, starting from phenomenological parameters, such as spectral indices,
peak fluxes and frequencies, and spectral curvatures, that the code evaluates automatically, the pre-fitting
algorithm is able to provide a good starting model, following the phenomenological trends that I have
implemented. fitting of multiwavelength SEDs using both frequentist approach (iminuit) and bayesian MCMC
- Self-consistent temporal evolution of the plasma under the effect of radiative and accelerative processes,
both first order and second order (stochastic acceleration) processes.
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.
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 .
MRExo performs non-parametric fitting and analysis of the mass-radius (M-R) relationship for exoplanets. Written in Python, it offers tools for fitting the M-R relationship to a given data set and also includes predicting (M->R, and R->M) and plotting functions.
STACKER stacks sources in interferometric data, i.e., averaging emission from different sources. The library allows stacking to be done directly on visibility data as well as in the image domain. The code is in format of a CASA (ascl:1107.013) task and implements uv- and image-stacking algorithms; it also provides several useful tasks for stacking related data processing. It allows introduction and stacking of random sources to estimate bias and noise, and also allows removal of a model of bright sources from the data.
Tangos builds databases (along the lines of Eagle or MultiDark) for cosmological and zoom simulations. Its
modular system generates and queries databases. It is designed to store and manage results from a user's own analysis code, provides web and python interfaces, and allows users to construct science-focused queries, including across entire merger trees, without requiring knowledge of SQL. Tangos manages the process of populating the database with science data, including auto-parallelizing the analysis. It can be customized to work with multiple python modules such as pynbody (ascl:1305.002) or yt (ascl:1011.022) to process raw simulation data; it defaults to using SQLite, but allows use of other databases as the underlying store through the use of SQLAlchemy.
PTMCMCSampler performs MCMC sampling using advanced techniques. The code implements a variety of proposal schemes, including adaptive Metropolis, differential evolution, and parallel tempering, which can be used together in the same run.
The Python package GWpy analyzes and characterizes gravitational wave data. It provides a user-friendly, intuitive interface to the common time-domain and frequency-domain data produced by the LIGO and Virgo observatories and their analyses. The core Python infrastructure is influenced by, and extends the functionality of, the Astropy (ascl:1304.002) package, and its methodology has been derived from, and augmented by, the LIGO Algorithm Library Suite (LALSuite), a large collection of primarily C99 routines for analysis and manipulation of data from gravitational-wave detectors. These packages use the SWIG program to produce Python wrappings for all C modules, allowing the GWpy package to leverage both the completeness, and the speed, of these libraries.
ENTERPRISE (Enhanced Numerical Toolbox Enabling a Robust PulsaR Inference SuitE) is a pulsar-timing analysis code which performs noise analysis, gravitational-wave searches, and timing model analysis. It uses Tempo2 (ascl:1210.015) to find the maximum-likelihood fit for the timing parameters and the basis of the fit for the red noise parameters if they are significant.
HARMPI is a parallel, 3D version of HARM (ascl:1209.005), which solves hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. The code is parallelized using MPI and is fully operational in 3D. HARMPI, like HARM, is capable of using non-uniform grids and solves the relativistic magnetohydrodynamic equations of motion on a stationary black hole spacetime in Kerr-Schild coordinates to evolve an accretion disk model.
GriSPy (Grid Search in Python) uses a regular grid search algorithm for quick fixed-radius nearest-neighbor lookup. It indexes a set of k-dimensional points in a regular grid providing a fast approach for nearest neighbors queries. Optional periodic boundary conditions can be provided for each axis individually. GriSPy implements three types of queries: bubble, shell and the nth-nearest, and offers three different metrics of interest in astronomy: the Euclidean and two distance functions in spherical coordinates of varying precision, haversine and Vincenty. It also provides a custom distance function. GriSPy is particularly useful for large datasets where a brute-force search is not practical.
GAME infers different ISM physical properties by analyzing the emission line intensities in a galaxy spectrum. The code is trained with a large library of synthetic spectra spanning many different ISM phases, including HII (ionized) regions, PDRs, and neutral regions. GAME is based on a Supervised Machine Learning algorithm called AdaBoost with Decision Trees as base learner. Given a set of input lines in a spectrum, the code performs a training on the library and then evaluates the line intensities to give a determination of the physical properties. The errors on the input emission line intensities and the uncertainties on the physical properties determinations are also taken into account. GAME infers gas density, column density, far-ultraviolet (FUV, 6–13.6 eV) flux, ionization parameter, metallicity, escape fraction, and visual extinction. A web interface for using the code is available.
QSOSIM realistically simulates high-resolution quasar spectra using a set of basic parameters (magnitude, redshift, and spectral index). The simulated spectra include physical effects seen in the real data: the power-law quasar continuum, the narrow and broad emission lines, absorption by neutral hydrogen (HI) in the Lyman alpha forest, and heavy element transitions along the line of sight. The code uses empirical HI column density, redshift, and b-parameter distributions to simulate absorption in the Lyman alpha forest. All absorbers with column densities larger than log [N(HI)/cm2]>17 have heavy element absorption, for which the column densities are calculated using the plasma simulation code CLOUDY (ascl:9910.001) and the radiative transfer code CUBA. The code also simulates the clustering of the intergalactic medium along the line of sight, the proximity effect of the quasar, and the effect of the cosmic ultraviolet background. Each simulated spectrum is saved in a single FITS file in as a noiseless R=100000 spectrum, as well as a spectrum convolved with Sloan Digital Sky Survey resolution (R=10000) and realistic noise.
Would you like to view a random code?