Results 2801-2900 of 3426 (3340 ASCL, 86 submitted)

[ascl:1111.002]
CRBLASTER: A Parallel-Processing Computational Framework for Embarrassingly-Parallel Image-Analysis Algorithms

The development of parallel-processing image-analysis codes is generally a challenging task that requires complicated choreography of interprocessor communications. If, however, the image-analysis algorithm is embarrassingly parallel, then the development of a parallel-processing implementation of that algorithm can be a much easier task to accomplish because, by definition, there is little need for communication between the compute processes. I describe the design, implementation, and performance of a parallel-processing image-analysis application, called CRBLASTER, which does cosmic-ray rejection of CCD (charge-coupled device) images using the embarrassingly-parallel L.A.COSMIC algorithm. CRBLASTER is written in C using the high-performance computing industry standard Message Passing Interface (MPI) library. The code has been designed to be used by research scientists who are familiar with C as a parallel-processing computational framework that enables the easy development of parallel-processing image-analysis programs based on embarrassingly-parallel algorithms. The CRBLASTER source code is freely available at the official application website at the National Optical Astronomy Observatory. Removing cosmic rays from a single 800x800 pixel Hubble Space Telescope WFPC2 image takes 44 seconds with the IRAF script lacos_im.cl running on a single core of an Apple Mac Pro computer with two 2.8-GHz quad-core Intel Xeon processors. CRBLASTER is 7.4 times faster processing the same image on a single core on the same machine. Processing the same image with CRBLASTER simultaneously on all 8 cores of the same machine takes 0.875 seconds -- which is a speedup factor of 50.3 times faster than the IRAF script. A detailed analysis is presented of the performance of CRBLASTER using between 1 and 57 processors on a low-power Tilera 700-MHz 64-core TILE64 processor.

[ascl:2206.009]
Craterstats3: Analyze and plot crater count data for planetary surface dating

Craterstats3 analyzes and plots crater count data for planetary surface dating. It is a Python implementation of Craterstats2 (ascl:2206.008) and is designed to replicate the output of the previous version as closely as possible. As before, it produces plots in cumulative, differential, Hartmann, and R-plot styles with possible overlays of crater counts, isochrons, equilibrium functions and epoch boundaries, as well aschronology and impact rate functions. Data can be shown with various binnings or unbinned, and age estimates made by either cumulative fitting, differential fitting, or Poisson timing evaluation. Numerical results can be output as text for further processing elsewhere. A number of published chronology systems are already set up for use, but new ones may be added by the user. The software is designed to be easily integrated into other software, which could allow the addition of a graphical interface or the inclusion of some Craterstats functions into a GIS.

[ascl:2206.008]
Craterstats2: Planetary surface dating from crater size-frequency distribution measurements

Craterstats2 plots crater counts and determining surface ages. The software plots isochrons in cumulative, differential, R-plot and Hartmann presentations, and makes isochron fits to both cumulative and differential data. Hartmann-style piecewise production functions may also be used. A Python implementation of the software, Craterstats3, is also available.

[ascl:1101.008]
CRASH: A Block-Adaptive-Mesh Code for Radiative Shock Hydrodynamics

van der Holst, B.; Toth, G.; Sokolov, I. V.; Powell, K. G.; Holloway, J. P.; Myra, E. S.; Stout, Q.; Adams, M. L.; Morel, J. E.; Drake, R. P.

CRASH (Center for Radiative Shock Hydrodynamics) is a block adaptive mesh code for multi-material radiation hydrodynamics. The implementation solves the radiation diffusion model with the gray or multigroup method and uses a flux limited diffusion approximation to recover the free-streaming limit. The electrons and ions are allowed to have different temperatures and we include a flux limited electron heat conduction. The radiation hydrodynamic equations are solved in the Eulerian frame by means of a conservative finite volume discretization in either one, two, or three-dimensional slab geometry or in two-dimensional cylindrical symmetry. An operator split method is used to solve these equations in three substeps: (1) solve the hydrodynamic equations with shock-capturing schemes, (2) a linear advection of the radiation in frequency-logarithm space, and (3) an implicit solve of the stiff radiation diffusion, heat conduction, and energy exchange. We present a suite of verification test problems to demonstrate the accuracy and performance of the algorithms. The CRASH code is an extension of the Block-Adaptive Tree Solarwind Roe Upwind Scheme (BATS-R-US) code with this new radiation transfer and heat conduction library and equation-of-state and multigroup opacity solvers. Both CRASH and BATS-R-US are part of the publicly available Space Weather Modeling Framework (SWMF).

[ascl:2009.018]
CRAC: Cosmology R Analysis Code

CRAC (Cosmology R Analysis Code) provides R functions for cosmology. Its main functions are similar to the Python library CosmoloPy (ascl:2009.017); for example, it implements functions to compute spherical geometric quantities for cosmological research.

[ascl:2002.021]
CR-SISTEM: Symplectic integrator for lunar core-mantle and orbital dynamics

CR-SISTEM models lunar orbital and rotational dynamics, taking into account the effects of a liquid core. Orbits of the Moon and Earth are fully integrated, and other planets (or additional point-mass satellites) may be included in the integration. Lunar and solar tides on Earth, eccentricity and obliquity tides on the Moon, and lunar core-mantle friction are included. The integrator is one file (crsistem5.for) written in FORTRAN 90, uses seven input files (settings.in, planets.in, moons.in, tidal.in, lunar.in, precess.in and core.in), and has at least eight output files (planet101.out, moon101.out, pole.out, spin_orb.out, spin_ecl.out, cspin_ecl.out, long.out and clong.out); additional moons and planets would add more output. The input files provided with the code set up a 1 Myr simulation of a slow-spinning Moon on an orbit of 40 Earth radii, which will then dynamically relax to the lowest-energy state (in this case it is a synchronous rotation with a core spinning separately from the mantle).

[ascl:1102.012]
CPROPS: Bias-free Measurement of Giant Molecular Cloud Properties

CPROPS, written in IDL, processes FITS data cubes containing molecular line emission and returns the properties of molecular clouds contained within it. Without corrections for the effects of beam convolution and sensitivity to GMC properties, the resulting properties may be severely biased. This is particularly true for extragalactic observations, where resolution and sensitivity effects often bias measured values by 40% or more. We correct for finite spatial and spectral resolutions with a simple deconvolution and we correct for sensitivity biases by extrapolating properties of a GMC to those we would expect to measure with perfect sensitivity. The resulting method recovers the properties of a GMC to within 10% over a large range of resolutions and sensitivities, provided the clouds are marginally resolved with a peak signal-to-noise ratio greater than 10. We note that interferometers systematically underestimate cloud properties, particularly the flux from a cloud. The degree of bias depends on the sensitivity of the observations and the (u,v) coverage of the observations. In the Appendix to the paper we present a conservative, new decomposition algorithm for identifying GMCs in molecular-line observations. This algorithm treats the data in physical rather than observational units, does not produce spurious clouds in the presence of noise, and is sensitive to a range of morphologies. As a result, the output of this decomposition should be directly comparable among disparate data sets.

The CPROPS package contains within it a distribution of the CLUMPFIND code written by Jonathan Williams and described in Williams, de Geus, and Blitz (1994). The package is available as a stand alone package. If you make use of the CLUMPFIND functionality in the CPROPS package for a publication, please cite Jonathan's original article.

[ascl:1710.009]
CppTransport: Two- and three-point function transport framework for inflationary cosmology

CppTransport solves the 2- and 3-point functions of the perturbations produced during an inflationary epoch in the very early universe. It is implemented for models with canonical kinetic terms, although the underlying method is quite general and could be scaled to handle models with a non-trivial field-space metric or an even more general non-canonical Lagrangian.

[ascl:2205.021]
CPNest: Parallel nested sampling

CPNest performs Bayesian inference using the nested sampling algorithm. It is designed to be simple for the user to provide a model via a set of parameters, their bounds and a log-likelihood function. An optional log-prior function can be given for non-uniform prior distributions. The nested sampling algorithm is then used to compute the marginal likelihood or evidence. As a by-product the algorithm produces samples from the posterior probability distribution. The implementation is based on an ensemble MCMC sampler which can use multiple cores to parallelize computation.

[ascl:1402.010]
CPL: Common Pipeline Library

The Common Pipeline Library (CPL) is a set of ISO-C libraries that provide a comprehensive, efficient and robust software toolkit to create automated astronomical data reduction pipelines. Though initially developed as a standardized way to build VLT instrument pipelines, the CPL may be more generally applied to any similar application. The code also provides a variety of general purpose image- and signal-processing functions, making it an excellent framework for the creation of more generic data handling packages. The CPL handles low-level data types (images, tables, matrices, strings, property lists, etc.) and medium-level data access methods (a simple data abstraction layer for FITS files). It also provides table organization and manipulation, keyword/value handling and management, and support for dynamic loading of recipe modules using programs such as EsoRex (ascl:1504.003).

[ascl:1808.003]
CPF: Corral Pipeline Framework

Cabral, Juan; Sanchez, Bruno; Beroiz, Martin; Dominguez, Mariano; Lares, Marcelo; Gurovich, Sebastian; Granitto, Pablo

Corral generates astronomical pipelines. Data processing pipelines represent an important slice of the astronomical software library that include chains of processes that transform raw data into valuable information via data reduction and analysis. Written in Python, Corral features a Model-View-Controller design pattern on top of an SQL Relational Database capable of handling custom data models, processing stages, and communication alerts. It also provides automatic quality and structural metrics based on unit testing. The Model-View-Controller provides concept separation between the user logic and the data models, delivering at the same time multi-processing and distributed computing capabilities.

[ascl:2201.011]
COWS: Cosmic web filament finder

Pfeifer, Simon; Libeskind, Noam I.; Hoffman, Yehuda; Hellwing, Wojciech A.; Bilicki, Maciej; Naidoo, Krishna

COWS (COsmic Web Skeleton) implements the cosmic filament finder COsmic Web Skeleton (COWS). Written in Python, the cosmic filament finder works on Hessian-based cosmic web identifiers (such as the V-web) and returns a catalogue of filament spines. The code identifies the medial axis, or skeleton, of cosmic web filaments and then separates this skeleton into individual filaments.

[ascl:1904.028]
covdisc: Disconnected covariance of 2-point functions in large-scale structure of the Universe

covdisc computes the disconnected part of the covariance matrix of 2-point functions in large-scale structure studies, accounting for the survey window effect. This method works for both power spectrum and correlation function, and applies to the covariances for various probes including the multi- poles and the wedges of 3D clustering, the angular and the projected statistics of clustering and lensing, as well as their cross covariances.

[ascl:1512.013]
CounterPoint: Zeeman-split absorption lines

CounterPoint works in concert with MoogStokes (ascl:1308.018). It applies the Zeeman effect to the atomic lines in the region of study, splitting them into the correct number of Zeeman components and adjusting their relative intensities according to the predictions of Quantum Mechanics, and finally creates a Moog-readable line list for use with MoogStokes. CounterPoint has the ability to use VALD and HITRAN line databases for both atomic and molecular lines.

[ascl:1307.010]
cosmoxi2d: Two-point galaxy correlation function calculation

Cosmoxi2d is written in C and computes the theoretical two-point galaxy correlation function as a function of cosmological and galaxy nuisance parameters. It numerically evaluates the model described in detail in Reid and White 2011 (arxiv:1105.4165) and Reid et al. 2012 (arxiv:1203.6641) for the multipole moments (up to ell = 4) for the observed redshift space correlation function of biased tracers as a function of cosmological (though an input linear matter power spectrum, growth rate f, and Alcock-Paczynski geometric factors alphaperp and alphapar) as well as nuisance parameters describing the tracers (bias and small scale additive velocity dispersion, isotropicdisp1d).

This model works best for highly biased tracers where the 2nd order bias term is small. On scales larger than 100 Mpc, the code relies on 2nd order Lagrangian Perturbation theory as detailed in Matsubara 2008 (PRD 78, 083519), and uses the analytic version of Reid and White 2011 on smaller scales.

[ascl:1504.010]
CosmoTransitions: Cosmological Phase Transitions

CosmoTransitions analyzes early-Universe finite-temperature phase transitions with multiple scalar fields. The code enables analysis of the phase structure of an input theory, determines the amount of supercooling at each phase transition, and finds the bubble-wall profiles of the nucleated bubbles that drive the transitions.

[ascl:1311.009]
CosmoTherm: Thermalization code

CosmoTherm allows precise computation of CMB spectral distortions caused by energy release in the early Universe. Different energy-release scenarios (e.g., decaying or annihilating particles) are implemented using the Green's function of the cosmological thermalization problem, allowing fast computation of the distortion signal. The full thermalization problem can be solved on a case-by-case basis for a wide range of energy-release scenarios using the full PDE solver of CosmoTherm. A simple Monte-Carlo toolkit is included for parameter estimation and forecasts using the Green's function method.

[ascl:1701.004]
CosmoSlik: Cosmology sampler of likelihoods

CosmoSlik quickly puts together, runs, and analyzes an MCMC chain for analysis of cosmological data. It is highly modular and comes with plugins for CAMB (ascl:1102.026), CLASS (ascl:1106.020), the Planck likelihood, the South Pole Telescope likelihood, other cosmological likelihoods, emcee (ascl:1303.002), and more. It offers ease-of-use, flexibility, and modularity.

[ascl:1409.012]
CosmoSIS: Cosmological parameter estimation

Zuntz, Joe; Paterno, Marc; Jennings, Elise; Rudd, Douglas; Manzotti, Alessandro; Dodelson, Scott; Bridle, Sarah; Sehrish, Saba; Kowalkowski, James

CosmoSIS is a cosmological parameter estimation code. It structures cosmological parameter estimation to ease re-usability, debugging, verifiability, and code sharing in the form of calculation modules. Witten in python, CosmoSIS consolidates and connects existing code for predicting cosmic observables and maps out experimental likelihoods with a range of different techniques.

[ascl:2401.005]
CosmosCanvas: Useful color maps for different astrophysical properties

CosmosCanvas creates perception-based color maps for different astrophysical properties such as spectral index and velocity fields. Three tutorials demonstrate how to use python code to exploit and adjust the boundaries in these divergent colour schemes. Intended to work with human physiology, each tutorial offers at least one default scheme that is monotonic in value both as a redundancy for supporting data information and an aid for colour blind viewers. This library relies on Gilles Ferrand's colourspace library.

[ascl:1705.001]
COSMOS: Carnegie Observatories System for MultiObject Spectroscopy

COSMOS (Carnegie Observatories System for MultiObject Spectroscopy) reduces multislit spectra obtained with the IMACS and LDSS3 spectrographs on the Magellan Telescopes. It can be used for the quick-look analysis of data at the telescope as well as for pipeline reduction of large data sets. COSMOS is based on a precise optical model of the spectrographs, which allows (after alignment and calibration) an accurate prediction of the location of spectra features. This eliminates the line search procedure which is fundamental to many spectral reduction programs, and allows a robust data pipeline to be run in an almost fully automatic mode, allowing large amounts of data to be reduced with minimal intervention.

[ascl:1304.017]
CosmoRec: Cosmological Recombination code

CosmoRec solves the recombination problem including recombinations to highly excited states, corrections to the 2s-1s two-photon channel, HI Lyn-feedback, n>2 two-photon profile corrections, and n≥2 Raman-processes. The code can solve the radiative transfer equation of the Lyman-series photon field to obtain the required modifications to the rate equations of the resolved levels, and handles electron scattering, the effect of HeI intercombination transitions, and absorption of helium photons by hydrogen. It also allows accounting for dark matter annihilation and optionally includes detailed helium radiative transfer effects.

[ascl:1212.006]
CosmoPMC: Cosmology sampling with Population Monte Carlo

Kilbinger, Martin; Benabed, Karim; Cappé, Olivier; Coupon, Jean; Cardoso, Jean-François; Fort, Gersende; McCracken, Henry Joy; Prunet, Simon; Robert, Christian P.; Wraith, Darren

CosmoPMC is a Monte-Carlo sampling method to explore the likelihood of various cosmological probes. The sampling engine is implemented with the package pmclib. It is called Population MonteCarlo (PMC), which is a novel technique to sample from the posterior. PMC is an adaptive importance sampling method which iteratively improves the proposal to approximate the posterior. This code has been introduced, tested and applied to various cosmology data sets.

[ascl:1408.018]
CosmoPhotoz: Photometric redshift estimation using generalized linear models

de Souza, Rafael S.; Elliott, Jonathan; Krone-Martins, Alberto; Ishida, Emille E. O.; Hilbe, Joseph; Cameron, Ewan

CosmoPhotoz determines photometric redshifts from galaxies utilizing their magnitudes. The method uses generalized linear models which reproduce the physical aspects of the output distribution. The code can adopt gamma or inverse gaussian families, either from a frequentist or a Bayesian perspective. A set of publicly available libraries and a web application are available. This software allows users to apply a set of GLMs to their own photometric catalogs and generates publication quality plots with no involvement from the user. The code additionally provides a Shiny application providing a simple user interface.

[ascl:2001.010]
CosMOPED: Compressed Planck likelihood

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.

[ascl:1110.019]
CosmoNest: Cosmological Nested Sampling

CosmoNest is an algorithm for cosmological model selection. Given a model, defined by a set of parameters to be varied and their prior ranges, and data, the algorithm computes the evidence (the marginalized likelihood of the model in light of the data). The Bayes factor, which is proportional to the relative evidence of two models, can then be used for model comparison, i.e. to decide whether a model is an adequate description of data, or whether the data require a more complex model.

For convenience, CosmoNest, programmed in Fortran, is presented here as an optional add-on to CosmoMC (ascl:1106.025), which is widely used by the cosmological community to perform parameter fitting within a model using a Markov-Chain Monte-Carlo (MCMC) engine. For this reason it can be run very easily by anyone who is able to compile and run CosmoMC. CosmoNest implements a different sampling strategy, geared for computing the evidence very accurately and efficiently. It also provides posteriors for parameter fitting as a by-product.

[ascl:1106.025]
CosmoMC: Cosmological MonteCarlo

We present a fast Markov Chain Monte-Carlo exploration of cosmological parameter space. We perform a joint analysis of results from recent CMB experiments and provide parameter constraints, including sigma_8, from the CMB independent of other data. We next combine data from the CMB, HST Key Project, 2dF galaxy redshift survey, supernovae Ia and big-bang nucleosynthesis. The Monte Carlo method allows the rapid investigation of a large number of parameters, and we present results from 6 and 9 parameter analyses of flat models, and an 11 parameter analysis of non-flat models. Our results include constraints on the neutrino mass (m_nu < 0.3eV), equation of state of the dark energy, and the tensor amplitude, as well as demonstrating the effect of additional parameters on the base parameter constraints. In a series of appendices we describe the many uses of importance sampling, including computing results from new data and accuracy correction of results generated from an approximate method. We also discuss the different ways of converting parameter samples to parameter constraints, the effect of the prior, assess the goodness of fit and consistency, and describe the use of analytic marginalization over normalization parameters.

[ascl:1110.024]
CosmoMC SNLS: CosmoMC Plug-in to Analyze SNLS3 SN Data

This module is a plug-in for CosmoMC and requires that software. Though programmed to analyze SNLS3 SN data, it can also be used for other SN data provided the inputs are put in the right form. In fact, this is probably a good idea, since the default treatment that comes with CosmoMC is flawed. Note that this requires fitting two additional SN nuisance parameters (alpha and beta), but this is significantly faster than attempting to marginalize over them internally.

[ascl:2009.017]
CosmoloPy: Cosmology package for Python

CosmoloPy is a suite of cosmology routines built on NumPy/SciPy. Its capabilities include various cosmological densities, distance measures, and galaxy luminosity functions (Schecter functions). It also offers pre-defined sets of cosmological parameters (*e.g.*, from WMAP), conversion in and out of the AB magnitude system, and the reionization of the IGM. Functions take cosmological parameters (which can be numpy arrays) as keywords and ignore any extra keywords, making it possible to build a dictionary of cosmological parameters and pass it to any function.

[ascl:2006.006]
CosmoLike: Cosmological Likelihood analyses

CosmoLike analyzes cosmological data sets and forecasts future missions. It has been used in the analysis of the Dark Energy Survey and to optimize the Large Synoptic Survey Telescope and the Wide-Field Infrared Survey Telescope, and is useful for innovative theory projects that test new concepts and methods to enhance the constraining power of cosmological analyses.

[ascl:2312.007]
CosmoLED: Cosmo code for Large Extra Dimension (LED) black holes

CosmoLED computes Hawking evaporation from black holes and set constraints on the fraction of black holes in dark matter. Based on ExoCLASS (ascl:1106.020), the code provides a DarkAges_LED module and C codes in class_LED to compute the evolution and energy deposition functions from LED black holes. Though CosmoLED is designed for large extra dimension black holes, it can also be used to study 4D black holes.

[ascl:2311.012]
CosmoLattice: Lattice simulator of scalar and gauge field dynamics in an expanding universe

CosmoLattice performs lattice simulations of field dynamics in an expanding universe. The code can simulate the dynamics of interacting scalar field theories, Abelian U(1) gauge theories, and non-Abelian SU(2) gauge theories, either in flat spacetime or an expanding FLRW background, including the case of self-consistent expansion sourced by the fields themselves. It can also compute gravitational waves sourced by U(1) Abelian Gauge fields. The CosmoLattice platform can implement any system of dynamical equations suitable for discretization on a lattice, as it introduces its own language describing fields and operations between them, and hence can implement new libraries to solve arbitrary field problems (related or not to cosmology).

[ascl:1303.003]
CosmoHammer: Cosmological parameter estimation with the MCMC Hammer

CosmoHammer is a Python framework for the estimation of cosmological parameters. The software embeds the Python package emcee by Foreman-Mackey et al. (2012) and gives the user the possibility to plug in modules for the computation of any desired likelihood. The major goal of the software is to reduce the complexity when one wants to extend or replace the existing computation by modules which fit the user's needs as well as to provide the possibility to easily use large scale computing environments. CosmoHammer can efficiently distribute the MCMC sampling over thousands of cores on modern cloud computing infrastructure.

[ascl:2306.032]
CosmoGraphNet: Cosmological parameters and galaxy power spectrum from galaxy catalogs

CosmoGraphNet infers cosmological parameters or the galaxy power spectrum. It creates a graph from a galaxy catalog with information the 3D position and intrinsic galactic properties. A Graph Neural Network is then applied to predict the cosmological parameters or the galaxy power spectrum.

[ascl:2007.023]
CosmoGRaPH: Cosmological General Relativity and (Perfect fluid | Particle) Hydrodynamics

CosmoGRaPH explores cosmological problems in a fully general relativistic setting. Written in C++, it implements various novel methods for numerically solving the Einstein field equations, including an N-body solver, full AMR capabilities via SAMRAI, and raytracing.

[ascl:2009.020]
cosmoFns: Functions for observational cosmology

cosmoFns computes distances, times, luminosities, and other quantities useful in observational cosmology, including molecular line observations. Written in R and coded for a flat universe, it contains functions for rest-frame line and luminosities, cosmic lookback time given z and cosmological parameters, and differential comoving volume. cosmoFns also computes comoving, luminosity, and angular diameter distances and molecular mass, among other quantities.

[ascl:2006.005]
CosmoCov: Configuration space covariances for projected galaxy 2-point statistics

CosmoCov computes configuration space covariances for projected galaxy 2-point statistics based on the CosmoLike (ascl:2006.006) framework. The package provides a flat sky covariance module, computed with the 2D-FFTLog (ascl:2006.004) algorithm, and a curved sky covariance module.

[ascl:1511.019]
CosmoBolognaLib: Open source C++ libraries for cosmological calculations

CosmoBolognaLib contains numerical libraries for cosmological calculations; written in C++, it is intended to define a common numerical environment for cosmological investigations of the large-scale structure of the Universe. The software aids in handling real and simulated astronomical catalogs by measuring one-point, two-point and three-point statistics in configuration space and performing cosmological analyses. These open source libraries can be included in either C++ or Python codes.

[ascl:1505.013]
cosmoabc: Likelihood-free inference for cosmology

Ishida, Emille E. O.; Vitenti, Sandro D. P.; Penna-Lima, Mariana; Trindade, Arlindo M.; Cisewski, Jessi; de Souza, Rafael M.; Cameron, Ewan; Busti, Vinicius C.

Approximate Bayesian Computation (ABC) enables parameter inference for complex physical systems in cases where the true likelihood function is unknown, unavailable, or computationally too expensive. It relies on the forward simulation of mock data and comparison between observed and synthetic catalogs. cosmoabc is a Python Approximate Bayesian Computation (ABC) sampler featuring a Population Monte Carlo variation of the original ABC algorithm, which uses an adaptive importance sampling scheme. The code can be coupled to an external simulator to allow incorporation of arbitrary distance and prior functions. When coupled with the numcosmo library, it has been used to estimate posterior probability distributions over cosmological parameters based on measurements of galaxy clusters number counts without computing the likelihood function.

[ascl:9910.004]
COSMICS: Cosmological initial conditions and microwave anisotropy codes

COSMICS is a package of Fortran programs useful for computing transfer functions and microwave background anisotropy for cosmological models, and for generating gaussian random initial conditions for nonlinear structure formation simulations of such models. Four programs are provided: linger_con and linger_syn integrate the linearized equations of general relativity, matter, and radiation in conformal Newtonian and synchronous gauge, respectively; deltat integrates the photon transfer functions computed by the linger codes to produce photon anisotropy power spectra; and grafic tabulates normalized matter power spectra and produces constrained or unconstrained samples of the matter density field.

[ascl:1601.008]
CosmicPy: Interactive cosmology computations

CosmicPy performs simple and interactive cosmology computations for forecasting cosmological parameters constraints; it computes tomographic and 3D Spherical Fourier-Bessel power spectra as well as Fisher matrices for galaxy clustering. Written in Python, it relies on a fast C++ implementation of Fourier-Bessel related computations, and requires NumPy, SciPy, and Matplotlib.

[ascl:2307.027]
CosmicFish: Cosmology forecasting tool

CosmicFish obtains expected bounds on cosmological parameters for a wide range of models and observables for cosmological forecasting. The package includes a Fortran library to produce Fisher matrices, a Python library that performs operations on the produced Fisher matrices, and a full set of plotting utilities. It works with many models, including CAMB (ascl:1102.026) and MGCAMB (ascl:1106.013), and can interface with any Boltzmann solver. The user can choose within a wide range of possible cosmological observables, including cosmic microwave background, weak lensing tomography, galaxy clustering, and redshift drift. CosmicFish is easy to customize; it provides a flexible package system and users can produce their own analyses and plotting pipelines following the default Python apps.

[ascl:1304.006]
CosmicEmuLog: Cosmological Power Spectra Emulator

CosmicEmuLog is a simple Python emulator for cosmological power spectra. In addition to the power spectrum of the conventional overdensity field, it emulates the power spectra of the log-density as well as the Gaussianized density. It models fluctuations in the power spectrum at each k as a linear combination of contributions from fluctuations in each cosmological parameter. The data it uses for emulation consist of ASCII files of the mean power spectrum, together with derivatives of the power spectrum with respect to the five cosmological parameters in the space spanned by the Coyote Universe suite. This data can also be used for Fisher matrix analysis. At present, CosmicEmuLog is restricted to redshift 0.

[submitted]
CosmicEmu: High Precision Emulator for the Nonlinear Matter Power Spectrum

Moran, Kelly R.; Heitmann, Katrin; Lawrence, Earl; Habib, Salman; Bingham, Derek; Upadhye, Amol; Kwan, Juliana; Higdon, David; Payne, Richard

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.

[ascl:1010.030]
CosmicEmu: Cosmic Emulator for the Dark Matter Power Spectrum

Lawrence, Earl; Heitmann, Katrin; White, Martin; Higdon, David; Wagner, Christian; Habib, Salman; Williams, Brian

Many of the most exciting questions in astrophysics and cosmology, including the majority of observational probes of dark energy, rely on an understanding of the nonlinear regime of structure formation. In order to fully exploit the information available from this regime and to extract cosmological constraints, accurate theoretical predictions are needed. Currently such predictions can only be obtained from costly, precision numerical simulations. The "Coyote Universe'' simulation suite comprises nearly 1,000 N-body simulations at different force and mass resolutions, spanning 38 wCDM cosmologies. This large simulation suite enabled construct of a prediction scheme, or emulator, for the nonlinear matter power spectrum accurate at the percent level out to k~1 h/Mpc. This is the first cosmic emulator for the dark matter power spectrum.

[ascl:2108.022]
COSMIC: Compact Object Synthesis and Monte Carlo Investigation Code

Breivik, Katelyn; Coughlin, Scott; Zevin, Michael; Rodriguez, Carl L.; Kremer, Kyle; Ye, Claire S.; Andrews, Jeff J.; Kurkowski, Michael; Digman, Matthew C.; Larson, Shane L.; Rasio, Frederic A.

COSMIC (Compact Object Synthesis and Monte Carlo Investigation Code) generates synthetic populations with an adaptive size based on how the shape of binary parameter distributions change as the number of simulated binaries increases. It implements stellar evolution using SSE (ascl:1303.015) and binary interactions using BSE (ascl:1303.014). COSMIC can also be used to simulate a single binary at a time, a list of multiple binaries, a grid of binaries, or a fixed population size as well as restart binaries at a mid point in their evolution. The code is included in CMC-COSMIC (ascl:2108.023).

[ascl:2207.004]
cosmic-kite: Auto-encoding the Cosmic Microwave Background

Cosmic-kite performs a fast estimation of the TT Cosmic Microwave Background (CMB) power spectra corresponding to a set of cosmological parameters; it can also estimate the maximum-likelihood cosmological parameters from a power spectra. This software is an auto-encoder that was trained and calibrated using power spectra from random cosmologies computed with the CAMB code (ascl:1102.026).

[ascl:2108.018]
Cosmic-CoNN: Cosmic ray detection toolkit

Cosmic-CoNN detects cosmic rays (CR) in CCD-captured astronomical images. It offers a PyTorch deep-learning framework to train generic, robust CR detection models for ground- and space-based imaging data as well as spectroscopic observations. Cosmic-CoNN also includes a suite of tools, including console commands, a web app, and Python APIs, to make deep-learning models easily accessible.

[ascl:2107.023]
cosmic_variance: Cosmic variance calculator

Ucci, Graziano; Dayal, Pratika; Hutter, Anne; Yepes, Gustavo; Gottlöber, Stefan; Legrand, Laurent; Pentericci, Laura; Castellano, Marco; Choudhury, Tirthankar Roy

cosmic_variance calculates the cosmic variance during the Epoch of Reionization (EoR) for the UV Luminosity Function (UV LF), Stellar Mass Function (SMF), and Halo Mass Function (HMF). The three functions in the package provide the output as the cosmic variance expressed in percentage. The code is written in Python, and simple examples that show how to use the functions are provided.

[ascl:1010.040]
Cosmic String Simulations

Complicated cosmic string loops will fragment until they reach simple, non-intersecting ("stable") configurations. Through extensive numerical study, these attractor loop shapes are characterized including their length, velocity, kink, and cusp distributions. An initial loop containing $M$ harmonic modes will, on average, split into 3M stable loops. These stable loops are approximately described by the degenerate kinky loop, which is planar and rectangular, independently of the number of modes on the initial loop. This is confirmed by an analytic construction of a stable family of perturbed degenerate kinky loops. The average stable loop is also found to have a 40% chance of containing a cusp. This new analytic scheme explicitly solves the string constraint equations.

[ascl:1712.008]
CosApps: Simulate gravitational lensing through ray tracing and shear calculation

Cosmology Applications (CosApps) provides tools to simulate gravitational lensing using two different techniques, ray tracing and shear calculation. The tool ray_trace_ellipse calculates deflection angles on a grid for light passing a deflecting mass distribution. Using MPI, ray_trace_ellipse may calculate deflection in parallel across network connected computers, such as cluster. The program physcalc calculates the gravitational lensing shear using the relationship of convergence and shear, described by a set of coupled partial differential equations.

[ascl:1202.006]
CORSIKA: An Air Shower Simulation Program

CORSIKA (COsmic Ray Simulations for KAscade) is a program for detailed simulation of extensive air showers initiated by high energy cosmic ray particles. Protons, light nuclei up to iron, photons, and many other particles may be treated as primaries. The particles are tracked through the atmosphere until they undergo reactions with the air nuclei or, in the case of unstable secondaries, decay. The hadronic interactions at high energies may be described by several reaction models. Hadronic interactions at lower energies are described, and in particle decays all decay branches down to the 1% level are taken into account. Options for the generation of Cherenkov radiation and neutrinos exist. CORSIKA may be used up to and beyond the highest energies of 100 EeV.

[ascl:1703.003]
Corrfunc: Blazing fast correlation functions on the CPU

Corrfunc is a suite of high-performance clustering routines. The code can compute a variety of spatial correlation functions on Cartesian geometry as well Landy-Szalay calculations for spatial and angular correlation functions on a spherical geometry and is useful for, for example, exploring the galaxy-halo connection. The code is written in C and can be used on the command-line, through the supplied python extensions, or the C API.

[ascl:1211.004]
CORRFIT: Cross-Correlation Routines

CORRFIT is a set of routines that use the cross-correlation method to extract parameters of the line-of-sight velocity distribution from galactic spectra and stellar templates observed on the same system. It works best when the broadening function is well sampled at the spectral resolution used (e.g. 200 km/s dispersion at 2 Angstrom resolution). Results become increasingly sensitive to the spectral match between galaxy and template if the broadening function is not well sampled. CORRFIT does not work well for dispersions less than the velocity sampling interval ('delta' in the code) unless the template is perfect.

[ascl:1711.005]
correlcalc: Two-point correlation function from redshift surveys

correlcalc calculates two-point correlation function (2pCF) of galaxies/quasars using redshift surveys. It can be used for any assumed geometry or Cosmology model. Using BallTree algorithms to reduce the computational effort for large datasets, it is a parallelised code suitable for running on clusters as well as personal computers. It takes redshift (z), Right Ascension (RA) and Declination (DEC) data of galaxies and random catalogs as inputs in form of ascii or fits files. If random catalog is not provided, it generates one of desired size based on the input redshift distribution and mangle polygon file (in .ply format) describing the survey geometry. It also calculates different realisations of (3D) anisotropic 2pCF. Optionally it makes healpix maps of the survey providing visualization.

[ascl:1702.002]
corner.py: Corner plots

*corner.py* uses matplotlib to visualize multidimensional samples using a scatterplot matrix. In these visualizations, each one- and two-dimensional projection of the sample is plotted to reveal covariances. *corner.py* was originally conceived to display the results of Markov Chain Monte Carlo simulations and the defaults are chosen with this application in mind but it can be used for displaying many qualitatively different samples. An earlier version of *corner.py* was known as triangle.py.

[ascl:1406.003]
CoREAS: CORSIKA-based Radio Emission from Air Showers simulator

CoREAS is a Monte Carlo code for the simulation of radio emission from extensive air showers; it is an update of and successor code to REAS3 (ascl:1107.009). It implements the endpoint formalism for the calculation of electromagnetic radiation directly in CORSIKA (ascl:1202.006). As such, it is parameter-free, makes no assumptions on the emission mechanism for the radio signals, and takes into account the complete complexity of the electron and positron distributions as simulated by CORSIKA.

[ascl:1603.002]
CORBITS: Efficient Geometric Probabilities of Multi-Transiting Exoplanetary Systems

CORBITS (Computed Occurrence of Revolving Bodies for the Investigation of Transiting Systems) computes the probability that any particular group of exoplanets can be observed to transit from a collection of conjectured exoplanets orbiting a star. The efficient, semi-analytical code computes the areas bounded by circular curves on the surface of a sphere by applying elementary differential geometry. CORBITS is faster than previous algorithms, based on comparisons with Monte Carlo simulations, and tests show that it is extremely accurate even for highly eccentric planets.

[ascl:1112.012]
CORA: Emission Line Fitting with Maximum Likelihood

CORA analyzes emission line spectra with low count numbers and fits them to a line using the maximum likelihood technique. CORA uses a rigorous application of Poisson statistics. From the assumption of Poissonian noise, the software derives the probability for a model of the emission line spectrum to represent the measured spectrum. The likelihood function is used as a criterion for optimizing the parameters of the theoretical spectrum and a fixed point equation is derived allowing an efficient way to obtain line fluxes. CORA has been applied to an X-ray spectrum with the Low Energy Transmission Grating Spectrometer (LETGS) on board the Chandra observatory.

[ascl:1304.022]
Copter: Cosmological perturbation theory

Copter is a software package for doing calculations in cosmological perturbation theory. Specifically, Copter includes code for computing statistical observables in the large-scale structure of matter using various forms of perturbation theory, including linear theory, standard perturbation theory, renormalized perturbation theory, and many others. Copter is written in C++ and makes use of the Boost C++ library headers.

[ascl:2306.024]
COpops: Compute CO sizes and fluxes

Zagaria, Francesco; Facchini, Stefano; Miotello, Anna; Manara, Carlo F.; Toci, Claudia; Clarke, Cathie J.

COpops computes semi-analytically the CO flux of a disc (given initial conditions and age) under the assumption of LTE and optically thick emission. It then runs disc population synthesis using observationally-informed initial conditions. CO fluxes is one of the most easily accessible observables for studying disc evolution; COpops is a faster alternative to running computationally-expensive thermochemical models for hundreds of discs and is accurate, recovering agreement within a factor of three.

[ascl:1210.013]
ConvPhot: A profile-matching algorithm for precision photometry

ConvPhot measures colors between two images having different resolutions. ConvPhot is designed to work especially for faint galaxies, accurately measuring colors in relatively crowded fields. It makes full use of the spatial and morphological information contained in the highest quality images to analyze multiwavelength data with inhomogeneous image quality.

Written in 2007, ConvPhot has been superseded by T-PHOT (ascl:1609.001)

[ascl:1401.006]
convolve_image.pro: Common-Resolution Convolution Kernels for Space- and Ground-Based Telescopes

The IDL package convolve_image.pro transforms images between different instrumental point spread functions (PSFs). It can load an image file and corresponding kernel and return the convolved image, thus preserving the colors of the astronomical sources. Convolution kernels are available for images from Spitzer (IRAC MIPS), Herschel (PACS SPIRE), GALEX (FUV NUV), WISE (W1 - W4), Optical PSFs (multi- Gaussian and Moffat functions), and Gaussian PSFs; they allow the study of the Spectral Energy Distribution (SED) of extended objects and preserve the characteristic SED in each pixel.

[ascl:2212.025]
CONTROL: Colorado Ultraviolet Transit Experiment data reduction pipeline

Sreejith, A. G.; Fossati, Luca; Ambily, S.; Egan, Arika; Nell, Nicholas; France, Kevin; Fleming, Brian T.; Haas, Stephanie; Chambliss, Michael; DeCicco, Nicholas; Steller, Manfred

CONTROL (CUTE autONomous daTa ReductiOn pipeLine) produces science-quality output with a single command line with zero user interference for CUTE (Colorado Ultraviolet Transit Experiment) data. It can be used for any single order spectral data in any wavelength without any modification. The pipeline is governed by a parameter file, which is available with this distribution. CONTROL is fully automated and works in a series of steps following standard CCD reduction techniques. It creates a reduction log to track processes carried out and any parameters used.

[ascl:1609.023]
contbin: Contour binning and accumulative smoothing

Contbin bins X-ray data using contours on an adaptively smoothed map. The generated bins closely follow the surface brightness, and are ideal where the surface brightness distribution is not smooth, or the spectral properties are expected to follow surface brightness. Color maps can be used instead of surface brightness maps.

[ascl:2202.019]
Contaminante: Identify blended targets in Kepler, TESS, and K2 data

contaminante helps find the contaminant transiting source in NASA's Kepler, K2 or TESS data. When hunting for transiting planets, sometimes signals come from neighboring contaminants. This package helps users identify where the transiting signal comes from in their data. The code uses pixel level modeling of the TargetPixelFile data from NASA's astrophysics missions that are processed with the Kepler pipeline. The output of contaminante is a Python dictionary containing the source location and transit depth, and a contaminant location and depth. It can also output a figure showing where the main target is centered in all available TPFs, what the phase curve looks like for the main target, where the transiting source is centered in all available TPFs, if a transiting source is located outside the main target, or the transiting source phase curve, if a transiting source is located outside the main target.

[ascl:9905.001]
CONSKY: A Sky CCD Integration Simulation

This program addresses the question of what resources are needed to produce a continuous data record of the entire sky down to a given limiting visual magnitude. Toward this end, the program simulates a small camera/telescope or group of small camera/telescopes collecting light from a large portion of the sky. From a given stellar density derived from a Bahcall - Soneira Galaxy model, the program first converts star densities at visual magnitudes between 5 and 20 to number of sky pixels needed to monitor each star simultaneously. From pixels, the program converts input CCD parameters to needed telescope attributes, needed data storage space, and the length of time needed to accumulate data of photometric quality for stars of each limiting visual magnitude over the whole sky. The program steps though photometric integrations one second at a time and includes the contribution from a bright background, read noise, dark current, and atmospheric absorption.

[ascl:1210.011]
Consistent Trees: Gravitationally Consistent Halo Catalogs and Merger Trees for Precision Cosmology

Behroozi, Peter S.; Wechsler, Risa H.; Wu, Hao-Yi; Busha, Michael T.; Klypin, Anatoly A.; Primack, Joel R.

Consistent Trees generates merger trees and halo catalogs which explicitly ensure consistency of halo properties (mass, position, velocity, radius) across timesteps. It has demonstrated the ability to improve both the completeness (through detecting and inserting otherwise missing halos) and purity (through detecting and removing spurious objects) of both merger trees and halo catalogs. Consistent Trees is able to robustly measure the self-consistency of halo finders and to directly measure the uncertainties in halo positions, halo velocities, and the halo mass function for a given halo finder based on consistency between snapshots in cosmological simulations.

[ascl:2307.061]
connect: COsmological Neural Network Emulator of CLASS using TensorFlow

connect (COsmological Neural Network Emulator of CLASS using TensorFlow) emulates cosmological parameters using neural networks. This includes both sampling of training data and training of the actual networks using the TensorFlow library. connect aids in cosmological parameter inference by immensely speeding up the process, which is achieved by substituting the cosmological Einstein-Boltzmann solver codes, needed for every evaluation of the likelihood, with a neural network with a 10^{2} to 10^{3} times faster evaluation time. The code requires CLASS (ascl:1106.020) and Monte Python (ascl:1307.002) if iterative sampling is used.

[submitted]
Coniferest: Python package for active anomaly detection

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

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

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

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

[ascl:2207.027]
ConeRot: Velocity perturbations extractor

ConeRot extracts velocity perturbations in protoplanetary disks from observed line centroids maps ν∘, by creating axially-symmetric centroid maps. It also derives 3D rotation curves in disk-centered cylindrical coordinates, and can estimate the disk orientation based on line data alone. It approximates the unit opacity surface of an axially symmetric disc by a series of cones whose orientations are fit to the observed velocity centroid in concentric radial domains, or regions, with the disc orientation and the rotation curve both optimized to fit ν∘ in each region. ConeRot extracts the perturbations directly from observations without strong assumptions about the underlying disk model and employs a reduced number of free parameters.

[ascl:2306.042]
CONDUCT: Electron transport coefficients of magnetized stellar plasmas

CONDUCT calculates all components of kinetic tensors in fully ionized electron-ion plasmas at arbitrary magnetic field. It employs a thermal averaging with the Fermi distribution function and can be used when electrons are partially degenerate; it provides, along with the electrical and thermal conductivities, also thermopower (thermoelectric coefficient). CONDUCT takes into account collisions of the electrons with ions and (in solid phase) charged impurities as well as quantum effects on ionic motion in the solid phase. The code's outputs are the longitudinal, transverse, and off-diagonal (Hall) components of electrical and thermal conductivity tensors as well as the components of thermoelectric tensor.

[ascl:2306.035]
CONCEPT: COsmological N-body CodE in PyThon

CONCEPT (COsmological N-body CodE in PyThon) simulates cosmological structure formation. It can simulate matter particles evolving under self-gravity in an expanding background. The code offers multiple gravitational solvers and has adaptive time integration built in. In addition to particles, CONCEPT also evolves fluids at various levels of non-linearity, providing the means for the inclusion of more exotic species such as massive neutrinos, as well as for simulations consistent with general relativistic perturbation theory. Various non-standard species, such as decaying cold dark matter, are fully supported. CONCEPT includes a sophisticated initial condition generator and can output snapshots, power spectra, bispectra ,and several kinds of renders.

[ascl:1403.015]
computePk: Power spectrum computation

ComputePk computes the power spectrum in cosmological simulations. It is MPI parallel and has been tested up to a 4096^3 mesh. It uses the FFTW library. It can read Gadget-3 and GOTPM outputs, and computes the dark matter component. The user may choose between NGP, CIC, and TSC for the mass assignment scheme.

[ascl:2312.008]
CompressedFisher: Library for testing Fisher forecasts

The CompressedFisher library tests whether Fisher forecasts using simulated components are converged. The library contains tools to compute standard Fisher estimates, estimate the level of bias due to the finite number of simulations, and compute the compressed Fisher information. Typical usage of CompressedFisher requires two ensembles of simulations: one set of simulations is given at the fiducial parameters (𝜃) to estimate the covariance matrix. The second is a set of simulated derivatives; these can either be in the form of realizations of the derivatives themselves or simulations evaluate at a set of point in the neighborhood of the fiducial point that the code can use to estimate the derivatives.

[ascl:2105.005]
COMPAS: Rapid binary population synthesis code

COMPAS (Compact Object Mergers: Population Astrophysics & Statistics) draws properties for a binary star system from a set of initial distributions and evolves it from zero-age main sequence to the end of its life as two compact remnants. Evolution prescriptions and model parameters are easily adjustable in the software. COMPAS has been used for inference from observations of gravitational-wave mergers, Galactic neutron stars, X-ray binaries, and luminous red novae.

[ascl:1606.009]
Companion-Finder: Planets and binary companions in time series spectra

Companion-Finder looks for planets and binary companions in time series spectra by searching for the spectral lines of stellar companions to other stars observed with high-precision radial-velocity surveys.

[submitted]
Compact Binary Chebyshev Polynomial Representation Ephemeris Kernel

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

[ascl:2106.007]
CoMover: Bayesian probability of co-moving stars

CoMover determines the probability that two stars are co-moving and thus gravitationally bound. It uses the sky position, proper motion, parallax and optionally the heliocentric radial velocity of a host star (with their respective measurement errors), and compares it to the observables of a potential companion (with their respective measurement errors). The sky position and proper motion of the potential companion star are required, and its heliocentric radial velocity and parallax are facultative inputs to refine its co-moving probability.

If all kinematic observables of the host star are provided, a single spatial-kinematic model is built, consisting of a single 6-dimensional multivariate Gaussian in Galactic coordinates (XYZ) and space velocities (UVW). The observables of the potential companion are then compared to this model and a given field-stars model with Bayes' theorem by marginalizing over any missing kinematic observables of the companion star with analytical integral solutions. The field stars are modeled using a 10-component multivariate Gaussian, accurate for stars within a few hundred parsecs of the Sun. In the case where a heliocentric radial velocity is missing for the host star, the single host-star multivariate Gaussian model is replaced with a series of host star models and numerically marginalized over by taking the numerical sum of the host-star model probabilities.

[ascl:1402.028]
Commander 2: Bayesian CMB component separation and analysis

Bull, Phil; Eriksen, Hans Kristian; Gjerløw, Eirik; Gorski, Krzysztof; Jewell, Jeff; Seljebotn, Dag Sverre; Wehus, Ingunn

Commander 2 is a Gibbs sampling code for joint CMB estimation and component separation. The Commander framework uses a parametrized physical model of the sky to perform statistically-rigorous analyses of multi-frequency, multi-resolution CMB data on the full and partial (flat) sky, as well as cross-correlation analyses with large-scale structure datasets.

[ascl:1404.008]
Comet: Multifunction VOEvent broker

Comet is a Python implementation of the VOEvent Transport Protocol (VTP). VOEvent is the IVOA system for describing transient celestial events. Details of transients detected by many projects, including Fermi, Swift, and the Catalina Sky Survey, are currently made available as VOEvents, which is also the standard alert format by future facilities such as LSST and SKA. The core of Comet is a multifunction VOEvent broker, capable of receiving events either by subscribing to one or more remote brokers or by direct connection from authors; it can then both process those events locally and forward them to its own subscribers. In addition, Comet provides a tool for publishing VOEvents to the global VOEvent backbone.

[ascl:2210.007]
COMET: Emulated predictions of large-scale structure observables

Eggemeier, Alexander; Camacho-Quevedo, Benjamin; Pezzotta, Andrea; Crocce, Martin; Scoccimarro, Román; Sánchez, Ariel G.

COMET (Clustering Observables Modelled by Emulated perturbation Theory) provides emulated predictions of large-scale structure observables from models that are based on perturbation theory. It substantially speeds up these analytic computations without any relevant sacrifice in accuracy, enabling an extremely efficient exploration of large-scale structure likelihoods. At its core, COMET exploits an evolution mapping approach which gives it a high degree of flexibility and allows it to cover a wide cosmology parameter space at continuous redshifts up to z∼3z \sim 3z∼3. Among others, COMET supports parameters for cold dark matter density (ωc\omega_cωc), baryon density (ωb\omega_bωb), Scalar spectral index (nsn_sns), Hubble expansion rate (hhh) and Curvature density (ΩK\Omega_KΩK). The code can obtain the real-space galaxy power spectrum at one-loop order multipoles (monopole, quadrupole, hexadecapole) of the redshift-space, power spectrum at one-loop order, the linear matter power spectrum (with and without infrared resummation), Gaussian covariance matrices for the real-space power spectrum, and redshift-space multipoles and χ2\chi^2χ2's for arbitrary combinations of multipoles. COMET provides an easy-to-use interface for all of these computations.

[ascl:1708.024]
ComEst: Completeness Estimator

ComEst calculates the completeness of CCD images conducted in astronomical observations saved in the FITS format. It estimates the completeness of the source finder SExtractor (ascl:1010.064) on the optical and near-infrared (NIR) imaging of point sources or galaxies as a function of flux (or magnitude) directly from the image itself. It uses PyFITS (ascl:1207.009) and GalSim (ascl:1402.009) to perform the end-to-end estimation of the completeness and can also estimate the purity of the source detection.

[ascl:1911.024]
comb: Spectral line data reduction and analysis package

comb is a single-dish radio astronomy spectral line data reduction and analysis package developed at AT&T Bell labs and was used for data reduction for many single-dish telescopes, including Bell Labs 7-m, NRAO 12-m, DSN network, FCRAO 14-m, Arecibo, AST/RO, SEST, BIMA, and in 2011-2012, the Stratospheric Terahertz Observatory. A cookbook for the code is available.

[ascl:1606.007]
COMB: Compact embedded object simulations

COMB supports the simulation on the sphere of compact objects embedded in a stochastic background process of specified power spectrum. Support is provided to add additional white noise and convolve with beam functions. Functionality to support functions defined on the sphere is provided by the S2 code (ascl:1606.008); HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001) are also required.

[ascl:2306.034]
COLT: Monte Carlo radiative transfer and simulation analysis toolkit

Smith, Aaron; Safranek-Shrader, Chalence; Bromm, Volker; Milosavljević, Miloš; Kimock, Ben; Garaldi, Enrico; Yeh, Jessica Yuan-Chen

COLT (Cosmic Lyman-alpha Transfer) is a Monte Carlo radiative transfer (MCRT) solver for post-processing hydrodynamical simulations on arbitrary grids. These include a plane parallel slabs, spherical geometry, 3D Cartesian grids, adaptive resolution octrees, unstructured Voronoi tessellations, and secondary outputs. COLT also includes several visualization and analysis tools that exploit the underlying ray-tracing algorithms or otherwise benefit from an efficient hybrid MPI + OpenMP parallelization strategy within a flexible C++ framework.

[ascl:1501.016]
Colossus: COsmology, haLO, and large-Scale StrUcture toolS

Colossus is a collection of Python modules for cosmology and dark matter halos calculations. It performs cosmological calculations with an emphasis on structure formation applications, implements general and specific density profiles, and provides a large range of models for the concentration-mass relation, including a conversion to arbitrary mass definitions.

[ascl:1508.005]
ColorPro: PSF-corrected aperture-matched photometry

ColorPro automatically obtains robust colors across images of varied PSF. To correct for the flux lost in images with poorer PSF, the "detection image" is blurred to match the PSF of these other images, allowing observation of how much flux is lost. All photometry is performed in the highest resolution frame (images being aligned given WCS information in the FITS headers), and identical apertures are used in every image. Usually isophotal apertures are used, as determined by SExtractor (ascl:1010.064). Using SExSeg (ascl:1508.006), object aperture definitions can be pre-defined and object detections from different image filters can be combined automatically into a single comprehensive "segmentation map." After producing the final photometric catalog, ColorPro can automatically run BPZ (ascl:1108.011) to obtain Bayesian Photometric Redshifts.

[ascl:2111.009]
CoLoRe: Cosmological Lofty Realization

CoLoRe (Cosmological Lofty Realization) generates fast mock realizations of a given galaxy sample using a lognormal model or LPT for the matter density. Tt can simulate a variety of cosmological tracers, including photometric and spectroscopic galaxies, weak lensing, and intensity mapping. CoLoRe is a parallel C code, and its behavior is controlled primarily by the input param file.

[ascl:1802.014]
collapse: Spherical-collapse model code

collapse calculates the spherical−collapse for standard cosmological models as well as for dark energy models when the dark energy can be taken to be spatially homogeneous. The calculation is valid on sub−horizon scales and takes a top−hat perturbation to exist in an otherwise featureless cosmos and follows its evolution into the non−linear regime where it reaches a maximum size and then recollapses. collapse provides the user with the linear−collapse threshold (delta_c) and the virial overdensity (Delta_v) for the collapsed halo over a range of cosmic scale factors.

[ascl:2305.021]
COLIBRI: Cosmological libraries in Python

COLIBRÌ (which roughly stands for “Cosmological Libraries”) computes cosmological quantities such as ages, distances, power spectra, and correlation functions. It supports Lambda-CDM cosmologies plus extensions including massive neutrinos, non-flat geometries, evolving dark energy (w0-wa) models, and numerical recipes for f(R) gravity. COLIBRÌ is built especially for large-scale structure purposes and can interact with the Boltzmann solvers CAMB (ascl:1102.026) and CLASS (ascl:1106.020).

[ascl:2309.006]
CoLFI: Cosmological Likelihood-Free Inference

CoLFI (Cosmological Likelihood-Free Inference) estimates parameters directly from the observational data sets using neural density estimators (NDEs); it is a fully ANN-based framework that differs from the Bayesian inference. The package contains three NDEs that are used to estimate parameters: an artificial neural network (ANN), a mixture density network (MDN), and a mixture neural network (MNN). CoLFI can learn the conditional probability density using samples generated by models, and the posterior distribution can be obtained for given observational data.

[ascl:2306.047]
COLASolver: Particle-Mesh N-body code

COLASolver creates Particle-Mesh (PM) N-body simulations; the code is fast and very flexible, and can compute a wide range of models. For models with complex dynamics (screened models), it provides several options from doing it exactly to approximate but fast to just simulating linear theory equations. Every time-consuming operation is parallelized over MPI and OpenMP. It uses a slab-based parallelization that works well for fast approximate (COLA) simulations but does not perform as well for high resolution simulations. COLASolver can also be used as an analysis code for results from other simulations.

[ascl:1602.021]
COLAcode: COmoving Lagrangian Acceleration code

COLAcode is a serial particle mesh-based N-body code illustrating the COLA (COmoving Lagrangian Acceleration) method; it solves for Large Scale Structure (LSS) in a frame that is comoving with observers following trajectories calculated in Lagrangian Perturbation Theory (LPT). It differs from standard N-body code by trading accuracy at small-scales to gain computational speed without sacrificing accuracy at large scales. This is useful for generating large ensembles of accurate mock halo catalogs required to study galaxy clustering and weak lensing; such catalogs are needed to perform detailed error analysis for ongoing and future surveys of LSS.

[ascl:2306.041]
COFFE: COrrelation Function Full-sky Estimator

COFFE (COrrelation Function Full-sky Estimator) computes quantities in linear perturbation theory. It computes the full-sky and flat-sky 2-point correlation function (2PCF) of galaxy number counts, taking into account all of the effects, including density, RSD, and lensing. It also determines the full-sky, flat-sky, and redshift-averaged multipoles of the 2PCF, and the flat-sky Gaussian covariance matrix of the multipoles of the 2PCF.

[ascl:2111.008]
COCOPLOT: COlor COllapsed PLOTting software

The COCOPLOT (COlor COllapsed PLOTting) quick-look and context image code conveys spectral profile information from all of the spatial pixels in a 3D datacube as a single image using color. It can also identify and expose temporal behavior and display and highlight solar features. COCOPLOT thus aids in identifying regions of interest quickly. The software is available in Python and IDL, and can be used as a standalone package or integrated into other software.

[ascl:1202.012]
CoCoNuT: General relativistic hydrodynamics code with dynamical space-time evolution

CoCoNuT is a general relativistic hydrodynamics code with dynamical space-time evolution. The main aim of this numerical code is the study of several astrophysical scenarios in which general relativity can play an important role, namely the collapse of rapidly rotating stellar cores and the evolution of isolated neutron stars. The code has two flavors: CoCoA, the axisymmetric (2D) magnetized version, and CoCoNuT, the 3D non-magnetized version.

[ascl:1703.002]
COCOA: Simulating Observations of Star Cluster Simulations

COCOA (Cluster simulatiOn Comparison with ObservAtions) creates idealized mock photometric observations using results from numerical simulations of star cluster evolution. COCOA is able to present the output of realistic numerical simulations of star clusters carried out using Monte Carlo or N-body codes in a way that is useful for direct comparison with photometric observations. The code can simulate optical observations from simulation snapshots in which positions and magnitudes of objects are known. The parameters for simulating the observations can be adjusted to mimic telescopes of various sizes. COCOA also has a photometry pipeline that can use standalone versions of DAOPHOT (ascl:1104.011) and ALLSTAR to produce photometric catalogs for all observed stars.

[ascl:1406.017]
COCO: Conversion of Celestial Coordinates

The COCO program converts star coordinates from one system to another. Both the improved IAU system, post-1976, and the old pre-1976 system are supported. COCO can perform accurate transformations between multiple coordinate systems. COCO’s user-interface is spartan but efficient and the program offers control over report resolution. All input is free-format, and defaults are provided where this is meaningful. COCO uses SLALIB (ascl:1403.025) and is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1505.010]
COBS: COnstrained B-Splines

COBS (COnstrained B-Splines), written in R, creates constrained regression smoothing splines via linear programming and sparse matrices. The method has two important features: the number and location of knots for the spline fit are established using the likelihood-based Akaike Information Criterion (rather than a heuristic procedure); and fits can be made for quantiles (e.g. 25% and 75% as well as the usual 50%) in the response variable, which is valuable when the scatter is asymmetrical or non-Gaussian. This code is useful for, for example, estimating cluster ages when there is a wide spread in stellar ages at a chosen absorption, as a standard regression line does not give an effective measure of this relationship.

Would you like to view a random code?