Results 1301-1350 of 1956 (1928 ASCL, 28 submitted)

[ascl:1306.012]
LRG DR7 Likelihood Software

This software computes likelihoods for the Luminous Red Galaxies (LRG) data from the Sloan Digital Sky Survey (SDSS). It includes a patch to the existing CAMB software (the February 2009 release) to calculate the theoretical LRG halo power spectrum for various models. The code is written in Fortran 90 and has been tested with the Intel Fortran 90 and GFortran compilers.

[ascl:1306.013]
Bessel: Fast Bessel Function Jn(z) Routine for Large n,z

Bessel, written in the C programming language, uses an accurate scheme for evaluating Bessel functions of high order. It has been extensively tested against a number of other routines, demonstrating its accuracy and efficiency.

[ascl:1306.014]
ZEUS-2D: Simulation of fluid dynamical flows

ZEUS-2D is a hydrodynamics code based on ZEUS which adds a covariant differencing formalism and algorithms for compressible hydrodynamics, MHD, and radiation hydrodynamics (using flux-limited diffusion) in Cartesian, cylindrical, or spherical polar coordinates.

[ascl:1306.015]
VHD: Viscous pseudo-Newtonian accretion

VHD is a numerical study of viscous fluid accretion onto a black hole. The flow is axisymmetric and uses a pseudo-Newtonian potential to model relativistic effects near the event horizon. VHD is based on ZEUS-2D (Stone & Norman 1992) with the addition of an explicit scheme for the viscosity.

[ascl:1306.016]
Yaxx: Yet another X-ray extractor

Yaxx is a Perl script that facilitates batch data processing using Perl open source software and commonly available software such as CIAO/Sherpa, S-lang, SAS, and FTOOLS. For Chandra and XMM analysis it includes automated spectral extraction, fitting, and report generation. Yaxx can be run without climbing an extensive learning curve; even so, yaxx is highly configurable and can be customized to support complex analysis. yaxx uses template files and takes full advantage of the unique Sherpa / S-lang environment to make much of the processing user configurable. Although originally developed with an emphasis on X-ray data analysis, yaxx evolved to be a general-purpose pipeline scripting package.

[ascl:1305.001]
ESTER: Evolution STEllaire en Rotation

The ESTER code computes the steady state of an isolated star of mass larger than two solar masses. The only convective region computed as such is the core where isentropy is assumed. ESTER provides solutions of the partial differential equations, for the pressure, density, temperature, angular velocity and meridional velocity for the whole volume. The angular velocity (differential rotation) and meridional circulation are computed consistently with the structure and are driven by the baroclinic torque. The code uses spectral methods, both radially and horizontally, with spherical harmonics and Chebyshev polynomials. The iterations follow Newton's algorithm. The code is object-oriented and is written in C++; a python suite allows an easy visualization of the results. While running, PGPLOT graphs are displayed to show evolution of the iterations.

[ascl:1305.002]
pynbody: N-Body/SPH analysis for python

Pynbody is a lightweight, portable, format-transparent analysis package for astrophysical N-body and smooth particle hydrodynamic simulations supporting PKDGRAV/Gasoline, Gadget, N-Chilada, and RAMSES AMR outputs. Written in python, the core tools are accompanied by a library of publication-level analysis routines.

[ascl:1305.003]
TPM: Tree-Particle-Mesh code

TPM carries out collisionless (dark matter) cosmological N-body simulations, evolving a system of N particles as they move under their mutual gravitational interaction. It combines aspects of both Tree and Particle-Mesh algorithms. After the global PM forces are calculated, spatially distinct regions above a given density contrast are located; the tree code calculates the gravitational interactions inside these denser objects at higher spatial and temporal resolution. The code is parallel and uses MPI for message passing.

[ascl:1305.004]
AdaptaHOP: Subclump finder

AdaptaHOP is a structure and substructure detector. It reads an input particle distribution file and can compute the mean square distance between each particle and its nearest neighbors or the SPH density associated to each particle + the list of its nearest neighbors. It can also read an input particle distribution and a neighbors file (output from a previous run) and output the tree of the structures in structures.

[ascl:1305.005]
PkdGRAV2: Parallel fast-multipole cosmological code

PkdGRAV2 is a high performance N-body treecode for self-gravitating astrophysical simulations. It is designed to run efficiently in serial and on a wide variety of parallel computers including both shared memory and message passing architectures. It can spatially adapt to large ranges in particle densities, and temporally adapt to large ranges in dynamical timescales. The code uses a non-standard data structure for efficiently calculating the gravitational forces, a variant on the k-D tree, and a novel method for treating periodic boundary conditions.

[ascl:1305.006]
Pressure-Entropy SPH: Pressure-entropy smooth-particle hydrodynamics

Pressure-Entropy SPH, a modified version of GADGET-2, uses the Lagrangian “Pressure-Entropy” formulation of the SPH equations. This removes the spurious “surface tension” force substantially improving the treatment of fluid mixing and contact discontinuities. Pressure-Entropy SPH shows good performance in mixing experiments (e.g. Kelvin-Helmholtz & blob tests), with conservation maintained even in strong shock/blastwave tests, where formulations without manifest conservation produce large errors. This improves the treatment of sub-sonic turbulence and lessens the need for large kernel particle numbers.

[ascl:1305.007]
PINOCCHIO: PINpointing Orbit-Crossing Collapsed HIerarchical Objects

PINOCCHIO generates catalogues of cosmological dark matter halos with known mass, position, velocity and merger history. It is able to reproduce, with very good accuracy, the hierarchical formation of dark matter halos from a realization of an initial (linear) density perturbation field, given on a 3D grid. Its setup is similar to that of a conventional N-body simulation, but it is based on the powerful Lagrangian Perturbation Theory. It runs in just a small fraction of the computing time taken by an equivalent N-body simulation, producing promptly the merging histories of all halos in the catalog.

[ascl:1305.008]
YNOGK: Calculating null geodesics in the Kerr spacetime

YNOGK, written in Fortran, calculates the null geodesics in the Kerr spacetime. It uses Weierstrass' and Jacobi's elliptic functions to express all coordinates and affine parameters as analytical and numerical functions of a parameter $p$, which is an integral value along the geodesic. The information about the turning points do not need to be specified in advance by the user, allowing applications such as imaging, the calculation of line profiles or the observer-emitter problem to become root finding problems. Elliptic integrations are computed by Carlson's elliptic integral method, which allows fast computation.

[ascl:1305.009]
GaussFit: Solving least squares and robust estimation problems

GaussFit solves least squares and robust estimation problems; written originally for reduction of NASA Hubble Space Telescope data, it includes a complete programming language designed especially to formulate estimation problems, a built-in compiler and interpreter to support the programming language, and a built-in algebraic manipulator for calculating the required partial derivatives analytically. The code can handle nonlinear models, exact constraints, correlated observations, and models where the equations of condition contain more than one observed quantity. Written in C, GaussFit includes an experimental robust estimation capability so data sets contaminated by outliers can be handled simply and efficiently.

[ascl:1305.010]
GILDAS: Grenoble Image and Line Data Analysis Software

GILDAS is a collection of software oriented toward (sub-)millimeter radioastronomical applications (either single-dish or interferometer). It has been adopted as the IRAM standard data reduction package and is jointly maintained by IRAM & CNRS. GILDAS contains many facilities, most of which are oriented towards spectral line mapping and many kinds of 3-dimensional data. The code, written in Fortran-90 with a few parts in C/C++ (mainly keyboard interaction, plotting, widgets), is easily extensible.

[ascl:1305.011]
FITDisk: Cataclysmic Variable Accretion Disk Demonstration Tool

FITDisk models accretion disk phenomena using a fully three-dimensional hydrodynamics calculation, and data can either be visualized as they are computed or stored to hard drive for later playback at a fast frame rate. Simulations are visualized using OpenGL graphics and the viewing angle can be changed interactively. Pseudo light curves of simulated systems can be plotted along with the associated Fourier amplitude spectrum. It provides an easy to use graphical user interface as well as 3-D interactive graphics. The code computes the evolution of a CV accretion disk, visualizes results in real time, records and plays back simulations, and generates and plots pseudo light curves and associated power spectra. FITDisk is the Windows executable form of this software; its Fortran source code is also available as DiskSim (ascl:1811.013).

[ascl:1305.012]
MapCUMBA: Multi-grid map-making algorithm for CMB experiments

The MapCUMBA package applies a multigrid fast iterative Jacobi algorithm for map-making in the context of CMB experiments.

[ascl:1305.013]
Non-Gaussian Realisations

Non-Gaussian Realisations provides code based on a spectral distortion/quantile transformation that generates a realization of a field on a cubic grid that has a specified probability distribution function and a specified power spectrum.

[ascl:1305.014]
TAU: 1D radiative transfer code for transmission spectroscopy of extrasolar planet atmospheres

TAU is a 1D line-by-line radiative transfer code for modeling transmission spectra of close-in extrasolar planets. The code calculates the optical path through the planetary atmosphere of the radiation from the host star and quantifies the absorption due to the modeled composition in a transmission spectrum of transit depth as a function of wavelength. The code is written in C++ and is parallelized using OpenMP.

[ascl:1305.015]
Merger Trees: Formation history of dark matter haloes

Merger Trees uses a Monte Carlo algorithm to generate merger trees describing the formation history of dark matter haloes; the algorithm is implemented in Fortran. The algorithm is a modification of the algorithm of Cole et al. used in the GALFORM semi-analytic galaxy formation model (ascl:1510.005) based on the Extended Press–Schechter theory. It should be applicable to hierarchical models with a wide range of power spectra and cosmological models. It is tuned to be in accurate agreement with the conditional mass functions found in the analysis of merger trees extracted from the Λ cold dark matter Millennium N-body simulation. The code should be a useful tool for semi-analytic models of galaxy formation and for modelling hierarchical structure formation in general.

[ascl:1304.001]
PEC: Period Error Calculator

The PEC (Period Error Calculator) algorithm estimates the period error for eclipsing binaries observed by the Kepler Mission. The algorithm is based on propagation of error theory and assumes that observation of every light curve peak/minimum in a long time-series observation can be unambiguously identified. A simple C implementation of the PEC algorithm is available.

[ascl:1304.002]
Astropy: Community Python library for astronomy

Greenfield, Perry; Robitaille, Thomas; Tollerud, Erik; Aldcroft, Tom; Barbary, Kyle; Barrett, Paul; Bray, Erik; Crighton, Neil; Conley, Alex; Conseil, Simon; Davis, Matt; Deil, Christoph; Dencheva, Nadia; Droettboom, Michael; Ferguson, Henry; Ginsburg, Adam; Grollier, Frédéric; Moritz Günther, Hans; Hanley, Chris; Hsu, J. C.; Kerzendorf, Wolfgang; Kramer, Roban; Lian Lim, Pey; Muna, Demitri; Nair, Prasanth; Price-Whelan, Adrian; Shiga, David; Singer, Leo; Taylor, James; Turner, James; Woillez, Julien; Zabalza, Victor

Astropy provides a common framework, core package of code, and affiliated packages for astronomy in Python. Development is actively ongoing, with major packages such as PyFITS, PyWCS, vo, and asciitable already merged in. Astropy is intended to contain much of the core functionality and some common tools needed for performing astronomy and astrophysics with Python.

[ascl:1304.003]
GALSVM: Automated Morphology Classification

GALSVM is IDL software for automated morphology classification. It was specially designed for high redshift data but can be used at low redshift as well. It analyzes morphologies of galaxies based on a particular family of learning machines called support vector machines. The method can be seen as a generalization of the classical CAS classification but with an unlimited number of dimensions and non-linear boundaries between decision regions. It is fully automated and consequently well adapted to large cosmological surveys.

[ascl:1304.004]
Wqed: Lightcurve Analysis Suite

Wqed (pronounced "Wicked") is a set of tools developed by the Delaware Asteroseismic Research Center (DARC) to simplify the process of reducing time-series CCD data on variable stars. It does not provide tools to measure the brightness of stars in individual frames, focusing instead on what comes next:

- - selecting and removing data lost to cloud,

- removing the effects of light cloud and seeing variations,

- keeping track of what star a given data set refers to, and when that data was taken, and

- performing barycentric corrections to data.

[ascl:1304.005]
VOBOZ/ZOBOV: Halo-finding and Void-finding algorithms

VOBOZ (VOronoi BOund Zones) is an algorithm to find haloes in an N-body dark matter simulation which has little dependence on free parameters.

ZOBOV (ZOnes Bordering On Voidness) is an algorithm that finds density depressions in a set of points without any free parameters or assumptions about shape. It uses the Voronoi tessellation to estimate densities to find both voids and subvoids. It also measures probabilities that each void or subvoid arises from Poisson fluctuations.

[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.

[ascl:1304.007]
DESPOTIC: Derive the Energetics and SPectra of Optically Thick Interstellar Clouds

DESPOTIC (Derive the Energetics and SPectra of Optically Thick Interstellar Clouds), written in Python, represents optically thick interstellar clouds using a one-zone model and calculates line luminosities, line cooling rates, and in restricted cases line profiles using an escape probability formalism. DESPOTIC calculates clouds' equilibrium gas and dust temperatures and their time-dependent thermal evolution. The code allows rapid and interactive calculation of clouds' characteristic temperatures, identification of their dominant heating and cooling mechanisms, and prediction of their observable spectra across a wide range of interstellar environments.

[ascl:1304.008]
Diffusion.f: Diffusion of elements in stars

Diffusion.f is an exportable subroutine to calculate the diffusion of elements in stars. The routine solves exactly the Burgers equations and can include any number of elements as variables. The code has been used successfully by a number of different groups; applications include diffusion in the sun and diffusion in globular cluster stars. There are many other possible applications to main sequence and to evolved stars. The associated README file explains how to use the subroutine.

[ascl:1304.009]
Sérsic: Exact deprojection of Sérsic surface brightness profiles

Sérsic is an implementation of the exact deprojection of Sérsic surface brightness profiles described in Baes and Gentile (2011). This code depends on the mpmath python library for an implementation of the Meijer G function required by the Baes and Gentile (hereafter B+G) formulas for rational values of the Sérsic index. Sérsic requires rational Sérsic indices, but any irrational number can be approximated arbitrarily well by some rational number. The code also depends on scipy, but the dependence is mostly for testing. The implementation of the formulas and the formulas themselves have undergone comprehensive testing.

[ascl:1304.011]
TPZ: Trees for Photo-Z

TPZ, a parallel code written in python, produces robust and accurate photometric redshift PDFs by using prediction tree and random forests. The code also produces ancillary information about the sample used, such as prior unbiased errors estimations (giving an estimation of performance) and a ranking of importance of variables as well as a map of performance indicating where extra training data is needed to improve overall performance. It is designed to be easy to use and a tutorial is available.

[ascl:1304.012]
ORIGAMI: Structure-finding routine in N-body simulation

ORIGAMI is a dynamical method of determining the morphology of particles in a cosmological simulation by checking for whether, and in how many dimensions, a particle has undergone shell-crossing. The code is written in C and makes use of the Delaunay tessellation calculation routines from the VOBOZ package (which relies on the Qhull package).

[ascl:1304.013]
SFH: Star Formation History

SFH is an efficient IDL tool that quickly computes accurate predictions for the baryon budget history in a galactic halo.

[ascl:1304.014]
MPgrafic: A parallel MPI version of Grafic-1

MPgrafic is a parallel MPI version of Grafic-1 which can produce large cosmological initial conditions on a cluster without requiring shared memory. The real Fourier transforms are carried in place using fftw while minimizing the amount of used memory (at the expense of performance) in the spirit of Grafic-1. The writing of the output file is also carried in parallel. In addition to the technical parallelization, it provides three extensions over Grafic-1:

- it can produce power spectra with baryon wiggles (DJ Eisenstein and W. Hu, Ap. J. 496);
- it has the optional ability to load a lower resolution noise map corresponding to the low frequency component which will fix the larger scale modes of the simulation (extra flag 0/1 at the end of the input process) in the spirit of Grafic-2;
- it can be used in conjunction with constrfield, which generates initial conditions phases from a list of local constraints on density, tidal field density gradient and velocity.

[ascl:1304.015]
TVD: Total Variation Diminishing code

TVD solves the magnetohydrodynamic (MHD) equations by updating the fluid variables along each direction using the flux-conservative, second-order, total variation diminishing (TVD), upwind scheme of Jin & Xin. The magnetic field is updated separately in two-dimensional advection-constraint steps. The electromotive force (EMF) is computed in the advection step using the TVD scheme, and this same EMF is used immediately in the constraint step in order to preserve ∇˙B=0 without the need to store intermediate fluxes. The code is extended to three dimensions using operator splitting, and Runge-Kutta is used to get second-order accuracy in time. TVD offers high-resolution per grid cell, second-order accuracy in space and time, and enforcement of the ∇˙B=0 constraint to machine precision. Written in Fortran, It has no memory overhead and is fast. It is also available in a fully scalable message-passing parallel MPI implementation.

[ascl:1304.016]
Qhull: Quickhull algorithm for computing the convex hull

Qhull computes the convex hull, Delaunay triangulation, Voronoi diagram, halfspace intersection about a point, furthest-site Delaunay triangulation, and furthest-site Voronoi diagram. The source code runs in 2-d, 3-d, 4-d, and higher dimensions. Qhull implements the Quickhull algorithm for computing the convex hull. It handles roundoff errors from floating point arithmetic. It computes volumes, surface areas, and approximations to the convex hull.

[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:1304.018]
SZpack: Computation of Sunyaev-Zeldovich (SZ) signals

SZpack is a numerical library which allows fast and precise computation of the Sunyaev-Zeldovich (SZ) signal for hot, moving clusters of galaxies. Both explicit numerical integration as well as approximate representation of the SZ signals can be obtained. Variations of the electron temperature and bulk velocity along the line-of-sight can be included. SZpack allows very fast and precise (<~0.001% at frequencies h nu <~ 30kT_g and electron temperature kTe ~ 75 keV) computation and its accuracy practically eliminates uncertainties related to more expensive numerical evaluation of the Boltzmann collision term. It furthermore cleanly separates kinematic corrections from scattering physics, effects that previously have not been clarified.

[ascl:1304.019]
IFrIT: Ionization FRont Interactive Tool

IFrIT (Ionization FRont Interactive Tool) is a powerful general purpose visualization tool that can be used to visualize 3-dimensional data sets. IFrIT is written in C++ and is based on the Visualization ToolKit (VTK) and, optionally, uses a GUI toolkit Qt. IFrIT can visualize scalar, vector field, tensor, and particle data. Several visualization windows can exist at the same time, each one having a full set of visualization objects. Some visualization windows can share the data between them, while other windows can be fully independent. Images from several visualization windows can be combined into one image file on the disk, tiling some windows together, and inserting reduced versions of some windows into larger other windows. A large array of features is also available, including highly advanced animation capabilities, a complex set of lights, markers to label various points in space, and a capability to "pick" a point in the scene and retrieve information about the data at this location.

[ascl:1304.020]
pyCloudy: Tools to manage astronomical Cloudy photoionization code

PyCloudy is a Python library that handles input and output files of the Cloudy photoionization code (Gary Ferland). It can also generate 3D nebula from various runs of the 1D Cloudy code. pyCloudy allows you to:

- define and write input file(s) for Cloudy code. As you can have it in a code, you may generate automatically sets of input files, changing parameters from one to the other.
- read the Cloudy output files and play with the data: you will be able to plot line emissivity ratio vs. the radius of the nebula, the electron temperature, or any Cloudy output.
- build pseudo-3D models, a la Cloudy_3D, by running a set of models, changing parameters (e.g. inner radius, density) following angular laws, reading the outputs of the set of models and interpolating the results (Te, ne, line emissivities) in a 3D cube.

[ascl:1304.021]
PyNeb: Analysis of emission lines

PyNeb (previously PyNebular) is an update and expansion of the IRAF package NEBULAR; rewritten in Python, it is designed to be more user-friendly and powerful, increasing the speed, easiness of use, and graphic visualization of emission lines analysis. In PyNeb, the atom is represented as an n-level atom. For given density and temperature, PyNeb solves the equilibrium equations and determines the level populations. PyNeb can compute physical conditions from suitable diagnostic line ratios and level populations, critical densities and line emissivities, and can compute and display emissivity grids as a function of Te and Ne. It can also deredden line intensities, read and manage observational data, and plot and compare atomic data from different publications, and compute ionic abundances from line intensities and physical conditions and elemental abundances from ionic abundances and icfs.

[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:1303.001]
SWIFT: A solar system integration software package

SWIFT follows the long-term dynamical evolution of a swarm of test particles in the solar system. The code efficiently and accurately handles close approaches between test particles and planets while retaining the powerful features of recently developed mixed variable symplectic integrators. Four integration techniques are included: Wisdom-Holman Mapping; Regularized Mixed Variable Symplectic (RMVS) method; fourth order T+U Symplectic (TU4) method; and Bulirsch-Stoer method. The package is designed so that the calls to each of these look identical so that it is trivial to replace one with another. Complex data manipulations and results can be analyzed with the graphics packace SwiftVis.

[ascl:1303.002]
emcee: The MCMC Hammer

Foreman-Mackey, Daniel; Conley, Alex; Meierjurgen Farr, Will; Hogg, David W.; Lang, Dustin; Marshall, Phil; Price-Whelan, Adrian; Sanders, Jeremy; Zuntz, Joe

emcee is an extensible, pure-Python implementation of Goodman & Weare's Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler. It's designed for Bayesian parameter estimation. The algorithm behind emcee has several advantages over traditional MCMC sampling methods and has excellent performance as measured by the autocorrelation time (or function calls per independent sample). One advantage of the algorithm is that it requires hand-tuning of only 1 or 2 parameters compared to $sim N^2$ for a traditional algorithm in an N-dimensional parameter space. Exploiting the parallelism of the ensemble method, emcee permits any user to take advantage of multiple CPU cores without extra effort.

[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:1303.004]
UCL_PDR: Time dependent photon-dissociation regions model

UCL_PDR is a time dependent photon-dissociation regions model that calculates self consistently the thermal balance. It can be used with gas phase only species as well as with surface species. It is very modular, has the possibility of accounting for density and pressure gradients and can be coupled with UCL_CHEM as well as with SMMOL. It has been used to model small scale (e.g. knots in proto-planetary nebulae) to large scale regions (high redshift galaxies).

[ascl:1303.005]
SMMOL: Spherical Multi-level MOLecular line radiative transfer

SMMOL (Spherical Multi-level MOLecular line radiative transfer) is a molecular line radiative transfer code that uses Accelerated Lambda Iteration to solve the coupled level population and line transfer problem in spherical geometry. The code uses a discretized grid and a ray tracing methodology. SMMOL is designed for high optical depth regimes and can cope with maser emission as long as the spatial-velocity sampling is fine enough.

[ascl:1303.006]
UCL_CHEM: time and depth dependent gas-grain chemical model

UCL_CHEM is a time and depth dependent gas-grain chemical model that can be used to estimate the fractional abundances (with respect to hydrogen) of gas and surface species in every environment where molecules are present. The model includes both gas and surface reactions. The code starts from the most diffuse state where all the gas is in atomic form and evolve sthe gas to its final density. Depending on the temperature, atoms and molecules from the gas freeze on to the grains and they hydrogenate where possible. The advantage of this approach is that the ice composition is not assumed but it is derived by a time-dependent computation of the chemical evolution of the gas-dust interaction process. The code is very modular, has been used to model a variety of regions and can be coupled with the UCL_PDR and SMMOL codes.

[ascl:1303.007]
micrOMEGAs: Calculation of dark matter properties

micrOMEGAs calculates the properties of cold dark matter in a generic model of particle physics. First developed to compute the relic density of dark matter, the code also computes the rates for dark matter direct and indirect detection. The code provides the mass spectrum, cross-sections, relic density and exotic fluxes of gamma rays, positrons and antiprotons. The propagation of charged particles in the Galactic halo is handled with a module that allows to easily modify the propagation parameters. The cross-sections for both spin dependent and spin independent interactions of WIMPS on protons are computed automatically as well as the rates for WIMP scattering on nuclei in a large detector. Annihilation cross-sections of the dark matter candidate at zero velocity, relevant for indirect detection of dark matter, are computed automatically, and the propagation of charged particles in the Galactic halo is also handled.

[ascl:1303.008]
TYCHO: Stellar evolution code

TYCHO is a general, one dimensional (spherically symmetric) stellar evolution code written in structured Fortran 77; it is designed for hydrostatic and hydrodynamic stages including mass loss, accretion, pulsations and explosions. Mixing and convection algorithms are based on 3D time-dependent simulations. It offers extensive on-line graphics using Tim Pearson's PGPLOT with X-windows and runs effectively on Linux and Mac OS X laptop and desktop computers.

NOTE: This code is no longer being supported.

[ascl:1303.009]
MAGIX: Modeling and Analysis Generic Interface for eXternal numerical codes

MAGIX provides an interface between existing codes and an iterating engine that minimizes deviations of the model results from available observational data; it constrains the values of the model parameters and provides corresponding error estimates. Many models (and, in principle, not only astrophysical models) can be plugged into MAGIX to explore their parameter space and find the set of parameter values that best fits observational/experimental data. MAGIX complies with the data structures and reduction tools of Atacama Large Millimeter Array (ALMA), but can be used with other astronomical and with non-astronomical data.

Would you like to view a random code?