Results 651-700 of 3572 (3481 ASCL, 91 submitted)

[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: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: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: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: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: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:1308.009]
CReSyPS: Stellar population synthesis code

CReSyPS (Code Rennais de Synthèse de Populations Stellaires) is a stellar population synthesis code that determines core overshooting amount for Magellanic clouds main sequence stars.

[ascl:1612.009]
CRETE: Comet RadiativE Transfer and Excitation

CRETE (Comet RadiativE Transfer and Excitation) is a one-dimensional water excitation and radiation transfer code for sub-millimeter wavelengths based on the RATRAN code (ascl:0008.002). The code considers rotational transitions of water molecules given a Haser spherically symmetric distribution for the cometary coma and produces FITS image cubes that can be analyzed with tools like MIRIAD (ascl:1106.007). In addition to collisional processes to excite water molecules, the effect of infrared radiation from the Sun is approximated by effective pumping rates for the rotational levels in the ground vibrational state.

[ascl:2103.017]
CRIME: Cosmological Realizations for Intensity Mapping Experiments

CRIME (Cosmological Realizations for Intensity Mapping Experiments) generates mock realizations of intensity mapping observations of the neutral hydrogen distribution. It contains three separate tools, GetHI, ForGet, and JoinT. GetHI generates realizations of the temperature fluctuations due to the 21cm emission of neutral hydrogen. Optionally it can also generate a realization of the point-source continuum emission (for a given population) by sampling the same density distribution, though using this feature greatly affects performance. ForGet generates realizations of the different galactic and extra-galactic foregrounds relevant for intensity mapping experiments using some external datasets (e.g. the Haslam 408 MHz map) stored in the "data"folder. JoinT is provided for convenience; it joins the temperature maps generated by GetHI and ForGet and includes several instrument-dependent effects (in an overly simplistic way).

[ascl:1708.003]
CRISPRED: CRISP imaging spectropolarimeter data reduction pipeline

CRISPRED reduces data from the CRISP imaging spectropolarimeter at the Swedish 1 m Solar Telescope (SST). It performs fitting routines, corrects optical aberrations from atmospheric turbulence as well as from the optics, and compensates for inter-camera misalignments, field-dependent and time-varying instrumental polarization, and spatial variation in the detector gain and in the zero level offset (bias). It has an object-oriented IDL structure with computationally demanding routines performed in C subprograms called as dynamically loadable modules (DLMs).

[ascl:1110.020]
CROSS_CMBFAST: ISW-correlation Code

This code is an extension of CMBFAST4.5.1 to compute the ISW-correlation power spectrum and the 2-point angular ISW-correlation function for a given galaxy window function. It includes dark energy models specified by a constant equation of state (w) or a linear parameterization in the scale factor (w0,wa) and a constant sound speed (c2de). The ISW computation is limited to flat geometry. Differently from the original CMBFAST4.5 version dark energy perturbations are implemented for a general dark energy fluid specified by w(z) and c2de in synchronous gauge. For time varying dark energy models it is suggested not to cross the w=-1 line, as Dr. Wenkman says: "never cross the streams", bad things can happen.

[ascl:2106.004]
crowdsource: Crowded field photometry pipeline

crowdsource removes a rough sky (the median), find the brighter peaks and fits these sources, computes centroids, and then computes an improved PSF. With this model of the image, the code then iteratively subtracts it and recomputes the median to get a better sky estimate, finds fainter peaks, and calculates a better PSF. crowdsource performs at least four iterations, evaluates the results, and continues until certain thresholds are met. Once the iterative passes are complete, it makes one last pass. If no sources are detected and positions do not vary, it performs photometry for the existing list of stellar positions.

[submitted]
CRPropa 3.2

Alves Batista, Rafael; Becker Tjus, Julia; Dörner, Julien; Dundovic, Andrej; Eichmann, Björn; Frie, Antonius; Heiter, Christopher; Hoerbe, Mario R.; Kampert, Karl-Heinz; Merten, Lukas; Müller, Gero; Reichherzer, Patrick; Saveliev, Andrey; Schlegel, Leander; Sigl, Günter; van Vliet, Arjen; Winchen, Tobias

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

[ascl:1412.013]
CRPropa: Numerical tool for the propagation of UHE cosmic rays, gamma-rays and neutrinos

CRPropa computes the observable properties of UHECRs and their secondaries in a variety of models for the sources and propagation of these particles. CRPropa takes into account interactions and deflections of primary UHECRs as well as propagation of secondary electromagnetic cascades and neutrinos. CRPropa makes use of the public code SOPHIA (ascl:1412.014), and the TinyXML, CFITSIO (ascl:1010.001), and CLHEP libraries. A major advantage of CRPropa is its modularity, which allows users to implement their own modules adapted to specific UHECR propagation models. An updated version, CRPropa3 (ascl:2208.016), is available.

[ascl:2208.016]
CRPropa3: Simulation framework for propagating extraterrestrial ultra-high energy particles

Alves Batista, Rafael; Dundovic, Andrej; Erdmann, Martin; Kampert, Karl-Heinz; Kuempel, Daniel; Müller, Gero; Sigl, Guenter; van Vliet, Arjen; Walz, David; Winchen, Tobias

CRPropa3, an improved version of CRPropa2 (ascl:1412.013), provides a simulation framework to study the propagation of ultra-high-energy nuclei up to iron on their voyage through an (extra)galactic environment. It takes into account pion production, photodisintegration, and energy losses by pair production of all relevant isotopes in the ambient low-energy photon fields, as well as nuclear decay. CRPropa3 can model the deflection in (inter)galactic magnetic fields, the propagation of secondary electromagnetic cascades, and neutrinos for a multitude of scenarios for different source distributions and magnetic environments. It enables the user to predict the spectra of UHECR (and of their secondaries), their composition and arrival direction distribution. Additionally, the low-energy Galactic propagation can be simulated by solving the transport equation using stochastic differential equations. CRPropa3 features a very flexible simulation setup with python steering and shared-memory parallelization.

[ascl:2401.016]
CRR: Convex Ridge Regularizer

CRR (Convex Ridge Regularizer) takes the gradient of regularizers that are the sum of convex-ridge functions and parameterizes them using a neural network that has a single hidden layer with increasing and learnable activation functions. The neural network is trained within a few minutes as a multistep Gaussian denoiser, and offers improvements for denoising and image reconstruction over other methods with similar reliability.

[ascl:1202.007]
CRUNCH3D: Three-dimensional compressible MHD code

CRUNCH3D is a massively parallel, viscoresistive, three-dimensional compressible MHD code. The code employs a Fourier collocation spatial discretization, and uses a second-order Runge-Kutta temporal discretization. CRUNCH3D can be applied to MHD turbulence and magnetic fluxtube reconnection research.

[ascl:1308.011]
CRUSH: Comprehensive Reduction Utility for SHARC-2 (and more...)

CRUSH is an astronomical data reduction/imaging tool for certain imaging cameras, especially at the millimeter, sub-millimeter, and far-infrared wavelengths. It supports the SHARC-2, LABOCA, SABOCA, ASZCA, p-ArTeMiS, PolKa, GISMO, MAKO and SCUBA-2 instruments. The code is written entirely in Java, allowing it to run on virtually any platform. It is normally run from the command-line with several arguments.

[ascl:2205.015]
CS-ROMER: Compressed Sensing ROtation MEasure Reconstruction

CS-ROMER (Compressed Sensing ROtation MEasure Reconstruction) is a compressed sensing reconstruction framework for Faraday depth spectra. It can simulation Faraday depth sources, subtract Galactic RM, and reconstruct Faraday depth sources from linearly polarized data and Faraday depth sources using Compressed Sensing.

[ascl:0104.002]
CSENV: A code for the chemistry of CircumStellar ENVelopes

CSENV is a code that computes the chemical abundances for a desired set of species as a function of radius in a stationary, non-clumpy, CircumStellar ENVelope. The chemical species can be atoms, molecules, ions, radicals, molecular ions, and/or their specific quantum states. Collisional ionization or excitation can be incorporated through the proper chemical channels. The chemical species interact with one another and can are subject to photo-processes (dissociation of molecules, radicals, and molecular ions as well as ionization of all species). Cosmic ray ionization can be included. Chemical reaction rates are specified with possible activation temperatures and additional power-law dependences. Photo-absorption cross-sections vs. wavelength, with appropriate thresholds, can be specified for each species, while for H2+ a photoabsorption cross-section is provided as a function of wavelength and temperature. The photons originate from both the star and the external interstellar medium. The chemical species are shielded from the photons by circumstellar dust, by other species and by themselves (self-shielding). Shielding of continuum-absorbing species by these species (self and mutual shielding), line-absorbing species, and dust varies with radial optical depth. The envelope is spherical by default, but can be made bipolar with an opening solid-angle that varies with radius. In the non-spherical case, no provision is made for photons penetrating the envelope from the sides. The envelope is subject to a radial outflow (or wind), constant velocity by default, but the wind velocity can be made to vary with radius. The temperature of the envelope is specified (and thus not computed self-consistently).

[ascl:1106.019]
csra: Application of Compressive Sampling to Radio Astronomy I: Deconvolution

Compressive sampling is a new paradigm for sampling, based on sparseness of signals or signal representations. It is much less restrictive than Nyquist-Shannon sampling theory and thus explains and systematises the widespread experience that methods such as the Högbom CLEAN can violate the Nyquist-Shannon sampling requirements. In this paper, a CS-based deconvolution method for extended sources is introduced. This method can reconstruct both point sources and extended sources (using the isotropic undecimated wavelet transform as a basis function for the reconstruction step). We compare this CS-based deconvolution method with two CLEAN-based deconvolution methods: the Högbom CLEAN and the multiscale CLEAN. This new method shows the best performance in deconvolving extended sources for both uniform and natural weighting of the sampled visibilities. Both visual and numerical results of the comparison are provided.

[ascl:2406.011]
CTC: Color transformations calculator

Color transformations calculator determines the magnitude of a galaxy in a needed photometric band, given its color and magnitude in the original band. It supports various optical and near intrared surveys, including SDSS, DECaLS, DELVE, UKIDSS, VHS, and VIKING, and provides conversions for both total and aperture magnitudes with apertures of 1.5", 2" or 3" diameters. The source code, useful for performing bulk calculations, is available in Python and IDL; the calculator is also offered as a web service.

[ascl:1307.015]
CTI Correction Code

Massey, Richard; Stoughton, Chris; Leauthaud, Alexie; Rhodes, Jason; Koekemoer, Anton; Ellis, Richard; Shaghoulian, Edgar

Charge Transfer Inefficiency (CTI) due to radiation damage above the Earth's atmosphere creates spurious trailing in images from Charge-Coupled Device (CCD) imaging detectors. Radiation damage also creates unrelated warm pixels, which can be used to measure CTI. This code provides pixel-based correction for CTI and has proven effective in Hubble Space Telescope Advanced Camera for Surveys raw images, successfully reducing the CTI trails by a factor of ~30 everywhere in the CCD and at all flux levels. The core is written in java for speed, and a front-end user interface is provided in IDL. The code operates on raw data by returning individual electrons to pixels from which they were unintentionally dragged during readout. Correction takes about 25 minutes per ACS exposure, but is trivially parallelisable to multiple processors.

[ascl:1601.005]
ctools: Cherenkov Telescope Science Analysis Software

Knödlseder, Jürgen; Mayer, Michael; Deil, Christoph; Buehler, Rolf; Bregeon, Johan; Martin, Pierrick

ctools provides tools for the scientific analysis of Cherenkov Telescope Array (CTA) data. Analysis of data from existing Imaging Air Cherenkov Telescopes (such as H.E.S.S., MAGIC or VERITAS) is also supported, provided that the data and response functions are available in the format defined for CTA. ctools comprises a set of ftools-like binary executables with a command-line interface allowing for interactive step-wise data analysis. A Python module allows control of all executables, and the creation of shell or Python scripts and pipelines is supported. ctools provides cscripts, which are Python scripts complementing the binary executables. Extensions of the ctools package by user defined binary executables or Python scripts is supported. ctools are based on GammaLib (ascl:1110.007).

[ascl:2104.005]
CTR: Coronal Temperature Reconstruction

CTR (Coronal Temperature Reconstruction) reconstructs differential emission measures (DEMs) in the solar corona. Written in IDL, the code guarantees positivity of the recovered DEM, enforces an explicit smoothness constraint, returns a featureless (flat) solution in the absence of information, and converges quickly. The algorithm is robust and can be extended to other wavelengths where the DEM treatment is valid.

[ascl:1608.008]
Cuba: Multidimensional numerical integration library

The Cuba library offers four independent routines for multidimensional numerical integration: Vegas, Suave, Divonne, and Cuhre. The four algorithms work by very different methods, and can integrate vector integrands and have very similar Fortran, C/C++, and Mathematica interfaces. Their invocation is very similar, making it easy to cross-check by substituting one method by another. For further safeguarding, the output is supplemented by a chi-square probability which quantifies the reliability of the error estimate.

[ascl:1609.010]
CuBANz: Photometric redshift estimator

CuBAN*z* is a photometric redshift estimator code for high redshift galaxies that uses the back propagation neural network along with clustering of the training set, making it very efficient. The training set is divided into several self learning clusters with galaxies having similar photometric properties and spectroscopic redshifts within a given span. The clustering algorithm uses the color information (i.e. u-g, g-r etc.) rather than the apparent magnitudes at various photometric bands, as the photometric redshift is more sensitive to the flux differences between different bands rather than the actual values. The clustering method enables accurate determination of the redshifts. CuBAN*z* considers uncertainty in the photometric measurements as well as uncertainty in the neural network training. The code is written in C.

[ascl:1805.018]
CUBE: Information-optimized parallel cosmological N-body simulation code

CUBE, written in Coarray Fortran, is a particle-mesh based parallel cosmological N-body simulation code. The memory usage of CUBE can approach as low as 6 bytes per particle. Particle pairwise (PP) force, cosmological neutrinos, spherical overdensity (SO) halofinder are included.

[ascl:2208.023]
CubeFit: Regularized 3D fitting for spectro-imaging data

Cubefit is an OXY class that performs spectral fitting with spatial regularization in a spectro-imaging context. The 3D model is based on a 1D model and 2D parameter maps; the 2D maps are regularized using an L1L2 regularization by default. The estimator is a compound of a chi^2 based on the 1D model, a regularization term based of the 2D regularization of the various 2D parameter maps, and an optional decorrelation term based on the cross-correlation of specific pairs of parameter maps.

[ascl:1512.010]
CubeIndexer: Indexer for regions of interest in data cubes

Chilean Virtual Observatory; Araya, Mauricio; Candia, Gabriel; Gregorio, Rodrigo; Mendoza, Marcelo; Solar, Mauricio

CubeIndexer indexes regions of interest (ROIs) in data cubes reducing the necessary storage space. The software can process data cubes containing megabytes of data in fractions of a second without human supervision, thus allowing it to be incorporated into a production line for displaying objects in a virtual observatory. The software forms part of the Chilean Virtual Observatory (ChiVO) and provides the capability of content-based searches on data cubes to the astronomical community.

[ascl:1208.018]
CUBEP3M: High performance P3M N-body code

Harnois-Deraps, Joachim; Pen, Ue-Li; Iliev, Ilian T.; Merz, Hugh; Emberson, J. D.; Desjacques, Vincent

CUBEP^{3}M is a high performance cosmological N-body code which has many utilities and extensions, including a runtime halo finder, a non-Gaussian initial conditions generator, a tuneable accuracy, and a system of unique particle identification. CUBEP^{3}M is fast, has a memory imprint up to three times lower than other widely used N-body codes, and has been run on up to 20,000 cores, achieving close to ideal weak scaling even at this problem size. It is well suited and has already been used for a broad number of science applications that require either large samples of non-linear realizations or very large dark matter N-body simulations, including cosmological reionization, baryonic acoustic oscillations, weak lensing or non-Gaussian statistics.

[ascl:1805.031]
CubiCal: Suite for fast radio interferometric calibration

CubiCal implements several accelerated gain solvers which exploit complex optimization for fast radio interferometric gain calibration. The code can be used for both direction-independent and direction-dependent self-calibration. CubiCal is implemented in Python and Cython, and multiprocessing is fully supported.

A successor to CubiCal, QuartiCal (ascl:2305.006), is available.

[ascl:1111.007]
CUBISM: CUbe Builder for IRS Spectra Maps

Sings Irs Team; Smith, J. D.; Armus, Lee; Bot, Caroline; Buckalew, Brent; Dale, Danny; Helou, George; Jarrett, Tom; Roussel, Helene; Sheth, Kartik

CUBISM, written in IDL, constructs spectral cubes, maps, and arbitrary aperture 1D spectral extractions from sets of mapping mode spectra taken with Spitzer's IRS spectrograph. CUBISM is optimized for non-sparse maps of extended objects, e.g. the nearby galaxy sample of SINGS, but can be used with data from any spectral mapping AOR (primarily validated for maps which are designed as suggested by the mapping HOWTO).

[ascl:2105.016]
CUDAHM: MCMC sampling of hierarchical models with GPUs

CUDAHM accelerates Bayesian inference of Hierarchical Models using Markov Chain Monte Carlo by constructing a Metropolis-within-Gibbs MCMC sampler for a three-level hierarchical model, requiring the user to supply only a minimimal amount of CUDA code. CUDAHM assumes that a set of measurements are available for a sample of objects, and that these measurements are related to an unobserved set of characteristics for each object. For example, the measurements could be the spectral energy distributions of a sample of galaxies, and the unknown characteristics could be the physical quantities of the galaxies, such as mass, distance, or age. The measured spectral energy distributions depend on the unknown physical quantities, which enables one to derive their values from the measurements. The characteristics are also assumed to be independently and identically sampled from a parent population with unknown parameters (e.g., a Normal distribution with unknown mean and variance). CUDAHM enables one to simultaneously sample the values of the characteristics and the parameters of their parent population from their joint posterior probability distribution.

[ascl:2404.021]
cudisc: CUDA-accelerated 2D code for protoplanetary disc evolution simulations

cuDisc simulates the evolution of protoplanetary discs in both the radial and vertical dimensions, assuming axisymmetry. The code performs 2D dust advection-diffusion, dust coagulation/fragmentation, and radiative transfer. A 1D evolution model is also included, with the 2D gas structure calculated via vertical hydrostatic equilibrium. cuDisc requires a NVIDIA GPU.

[ascl:2408.009]
Cue: Nebular emission modeling

Li, Yijia; Leja, Joel; Johnson, Benjamin D.; Tacchella, Sandro; Davies, Rebecca; Belli, Sirio; Park, Minjung; Emami, Razieh

Cue interprets nebular emission across a wide range of ionizing conditions of galaxies. The software, based on Cloudy (ascl:9910.001), emulates a neural net. It does not require a specific ionizing spectrum as a source, instead approximating the ionizing spectrum with a 4-part piece-wise power-law. Along with the flexible ionizing spectra, Cue allows freedom in [O/H], [N/O], [C/O], gas density, and total ionizing photon budget.

[ascl:1810.015]
cuFFS: CUDA-accelerated Fast Faraday Synthesis

cuFFS (CUDA-accelerated Fast Faraday Synthesis) performs Faraday rotation measure synthesis; it is particularly well-suited for performing RM synthesis on large datasets. Compared to a fast single-threaded and vectorized CPU implementation, depending on the structure and format of the data cubes, cuFFs achieves an increase in speed of up to two orders of magnitude. The code assumes that the pixels values are IEEE single precision floating points (BITPIX=-32), and the input cubes must have 3 axes (2 spatial dimensions and 1 frequency axis) with frequency axis as NAXIS1. A package is included to reformat data with individual stokes Q and U channel maps to the required format. The code supports both the HDFITS format and the standard FITS format, and is written in C with GPU-acceleration achieved using Nvidia's CUDA parallel computing platform.

[ascl:1109.013]
CULSP: Fast Calculation of the Lomb-Scargle Periodogram Using Graphics Processing Units

I introduce a new code for fast calculation of the Lomb-Scargle periodogram, that leverages the computing power of graphics processing units (GPUs). After establishing a background to the newly emergent field of GPU computing, I discuss the code design and narrate key parts of its source. Benchmarking calculations indicate no significant differences in accuracy compared to an equivalent CPU-based code. However, the differences in performance are pronounced; running on a low-end GPU, the code can match 8 CPU cores, and on a high-end GPU it is faster by a factor approaching thirty. Applications of the code include analysis of long photometric time series obtained by ongoing satellite missions and upcoming ground-based monitoring facilities; and Monte-Carlo simulation of periodogram statistical properties.

[ascl:1311.007]
CUPID: Clump Identification and Analysis Package

The CUPID package allows the identification and analysis of clumps of emission within 1, 2 or 3 dimensional data arrays. Whilst targeted primarily at sub-mm cubes, it can be used on any regularly gridded 1, 2 or 3D data. A variety of clump finding algorithms are implemented within CUPID, including the established ClumpFind (ascl:1107.014) and GAUSSCLUMPS (ascl:1406.018) algorithms. In addition, two new algorithms called FellWalker and Reinhold are also provided. CUPID allows easy inter-comparison between the results of different algorithms; the catalogues produced by each algorithm contains a standard set of columns containing clump peak position, clump centroid position, the integrated data value within the clump, clump volume, and the dimensions of the clump. In addition, pixel masks are produced identifying which input pixels contribute to each clump. CUPID is distributed as part of the Starlink (ascl:1110.012) software collection.

[ascl:1311.008]
CUPID: Customizable User Pipeline for IRS Data

Written in c, the Customizable User Pipeline for IRS Data (CUPID) allows users to run the Spitzer IRS Pipelines to re-create Basic Calibrated Data and extract calibrated spectra from the archived raw files. CUPID provides full access to all the parameters of the BCD, COADD, BKSUB, BKSUBX, and COADDX pipelines, as well as the opportunity for users to provide their own calibration files (e.g., flats or darks). CUPID is available for Mac, Linux, and Solaris operating systems.

[ascl:1405.015]
CURSA: Catalog and Table Manipulation Applications

The CURSA package manipulates astronomical catalogs and similar tabular datasets. It provides facilities for browsing or examining catalogs; selecting subsets from a catalog; sorting and copying catalogs; pairing two catalogs; converting catalog coordinates between some celestial coordinate systems; and plotting finding charts and photometric calibration. It can also extract subsets from a catalog in a format suitable for plotting using other Starlink packages such as PONGO. CURSA can access catalogs held in the popular FITS table format, the Tab-Separated Table (TST) format or the Small Text List (STL) format. Catalogs in the STL and TST formats are simple ASCII text files. CURSA also includes some facilities for accessing remote on-line catalogs via the Internet. It is part of the Starlink software collection (ascl:1110.012).

[ascl:2101.013]
Curvit: Create light curves from UVIT data

Curvit produces light curves from UVIT (Ultraviolet Imaging Telescope) data. It uses the events list from the official UVIT L2 pipeline (version 6.3 onwards) as input. The makecurves function of curvit automatically detects sources from events list and creates light curves. Curvit provides source coordinates only in the instrument coordinate system. If you already have the source coordinates, the curve function of curvit can be used to create light curves. The package has several parameters that can be set by the user; some of these parameters have default values. Curvit is available on PyPI.

[ascl:2206.025]
CuspCore: Core formation in dark matter haloes and ultra-diffuse galaxies by outflow episodes

Freundlich, Jonathan; Jiang, Fangzhou; Dekel, Avishai; Cornuault, Nicolas; Ginzburg, Omry; Koskas, Rémy; Lapiner, Sharon; Dutton, Aaron; Macciò, Andrea V.

CuspCore describes the formation of flat cores in dark matter haloes and ultra-diffuse galaxies from feedback-driven outflow episodes. The halo response is divided into an instantaneous change of potential at constant velocities followed by an energy-conserving relaxation. The core assumption of the model is that the total energy E=U+K is conserved for each shell enclosing a given dark matter mass, which is treated in the code as a least-square minimization of the difference between the final and the initial energy of each shell.

[ascl:1505.016]
CUTE: Correlation Utilities and Two-point Estimation

CUTE (Correlation Utilities and Two-point Estimation) extracts any two-point statistic from enormous datasets with hundreds of millions of objects, such as large galaxy surveys. The computational time grows with the square of the number of objects to be correlated; technology provides multiple means to massively parallelize this problem and CUTE is specifically designed for these kind of calculations. Two implementations are provided: one for execution on shared-memory machines using OpenMP and one that runs on graphical processing units (GPUs) using CUDA.

[ascl:1708.018]
CUTEX: CUrvature Thresholding EXtractor

CuTEx analyzes images in the infrared bands and extracts sources from complex backgrounds, particularly star-forming regions that offer the challenges of crowding, having a highly spatially variable background, and having no-psf profiles such as protostars in their accreting phase. The code is composed of two main algorithms, the first an algorithm for source detection, and the second for flux extraction. The code is originally written in IDL language and it was exported in the license free GDL language. CuTEx could be used in other bands or in scientific cases different from the native case.

This software is also available as an on-line tool from the Multi-Mission Interactive Archive web pages dedicated to the Herschel Observatory.

[ascl:2210.030]
cuvarbase: fast period finding utilities for GPUs

cuvarbase provides a Python library for performing period finding (Lomb-Scargle, Phase Dispersion Minimization, Conditional Entropy, Box-least squares) on astronomical time-series datasets. Speedups over CPU implementations depend on the algorithm, dataset, and GPU capabilities but are typically ~1-2 orders of magnitude and are especially high for BLS and Lomb-Scargle.

[ascl:2008.017]
CVXOPT: Convex Optimization

CVXOPT makes the development of software for convex optimization applications straightforward by building on Python’s extensive standard library and on the strengths of Python as a high-level programming language. It offers efficient Python classes for dense and sparse matrices (real and complex) with Python indexing and slicing and overloaded operations for matrix arithmetic, an interface to the fast Fourier transform routines from FFTW, and an interface to most of the double-precision real and complex BLAS. It contains routines for linear, second-order cone, and semidefinite programming problems, and for nonlinear convex optimization. CVXOPT also provides an interface to LAPACK routines for solving linear equations and least-squares problems, matrix factorizations (LU, Cholesky, LDLT and QR), symmetric eigenvalue and singular value decomposition, and Schur factorization, and a modeling tool for specifying convex piecewise-linear optimization problems.

[ascl:2011.028]
CWITools: Tools for Cosmic Web Imager data

CWITools analyzes integral field spectroscopy data from the Palomar and Keck Cosmic Web Imagers, and can be adapted for any three-dimensional integral field spectroscopy data. The package is modular, allowing users to construct data analysis pipelines to suit their own scientific needs, and includes tools for reducing data cubes, extracting a target signal, making emission maps, spectra, and other products. It also fits emission line and radial profiles and obtains final scalar quantities such as size and luminosity, among other tasks. It also contains helper functions that can, for example, obtain the wavelength axis from a 3D header, and create an auto-populated list of nebular emission lines or sky lines.

[ascl:1606.003]
Cygrid: Cython-powered convolution-based gridding module for Python

The Python module Cygrid grids (resamples) data to any collection of spherical target coordinates, although its typical application involves FITS maps or data cubes. The module supports the FITS world coordinate system (WCS) standard; its underlying algorithm is based on the convolution of the original samples with a 2D Gaussian kernel. A lookup table scheme allows parallelization of the code and is combined with the HEALPix tessellation of the sphere for fast neighbor searches. Cygrid's runtime scales between O(n) and O(nlog n), with n being the number of input samples.

[ascl:2303.001]
cysgp4: Wrapper for C++ SGP4 satellite library

The cysgp4 Cython-powered package wraps the C++ SGP4 Library for computing satellite positions from two-line elements (TLE). It provides similar functionality as the sgp4 Python package, though also works well with arrays of TLEs and/or observing times and makes use of multi-core platforms (via OpenMP) to improve processing times.

Previous12345678910111213**14**15161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172Next

Would you like to view a random code?