Results 1401-1450 of 3505 (3416 ASCL, 89 submitted)

[ascl:2104.010]
OpTool: Command-line driven tool for creating complex dust opacities

Optool computes dust opacities and scattering matrices, for specific grain sizes or averaged over size distributions. It is derived from OpacityTool (ascl:2104.009) and implements the Distribution of Hollow Spheres (DHS) statistical method to approximate irregular and low porosity grains. Mie theory is available as a limiting case of DHS. It also implements the Tazaki Modified Mean Field Theory (MMF) to treat fractal and highly porous aggregates. The refractive index data for many astronomically relevant materials are compiled into the code, and external refractive index data can be used as well. A compact and intuitive command line interface makes it easy to construct complex particles on the fly. Available output formats are ASCII and FITS, including files directly readable by RADMC-3D (ascl:1202.015). A python interface to the FORTRAN program is included.

[ascl:1803.013]
optBINS: Optimal Binning for histograms

optBINS (optimal binning) determines the optimal number of bins in a uniform bin-width histogram by deriving the posterior probability for the number of bins in a piecewise-constant density model after assigning a multinomial likelihood and a non-informative prior. The maximum of the posterior probability occurs at a point where the prior probability and the the joint likelihood are balanced. The interplay between these opposing factors effectively implements Occam's razor by selecting the most simple model that best describes the data.

[ascl:2112.018]
Optab: Ideal-gas opacity tables generator

Optab, written in Fortran90, generates ideal-gas opacity tables. It computes opacity based on user-provided chemical equilibrium abundances, and outputs mean opacities as well as monochromatic opacities, thus providing opacity tables that are consistent with one's equation of state for radiation hydrodynamics simulations. For convenience, Optab also provides interfaces for FastChem (ascl:1804.025) or TEA (ascl:1505.031) for computing chemical abundances.

[submitted]
Opik Collision Probability

The Opik method gives the mean probability of collision of a small body with a given planet. It is a statistical value valid for an orbit with given (a,e,i) and undefined argument of perihelion. In some cases, the planet can eject the small body from the solar system; in these cases, the program estimates the mean time for the ejection. The Opik method does not take into account other perturbers than the planet considered, so it only provides an idea of the timescales involved.

[ascl:1411.004]
OPERA: Open-source Pipeline for Espadons Reduction and Analysis

OPERA (Open-source Pipeline for Espadons Reduction and Analysis) is an open-source collaborative software reduction pipeline for ESPaDOnS data. ESPaDOnS is a bench-mounted high-resolution echelle spectrograph and spectro-polarimeter designed to obtain a complete optical spectrum (from 370 to 1,050 nm) in a single exposure with a mode-dependent resolving power between 68,000 and 81,000. OPERA is fully automated, calibrates on two-dimensional images and reduces data to produce one-dimensional intensity and polarimetric spectra. Spectra are extracted using an optimal extraction algorithm. Though designed for CFHT ESPaDOnS data, the pipeline is extensible to other echelle spectrographs.

[ascl:1509.009]
OPERA: Objective Prism Enhanced Reduction Algorithms

OPERA (Objective Prism Enhanced Reduction Algorithms) automatically analyzes astronomical images using the objective-prism (OP) technique to register thousands of low resolution spectra in large areas. It detects objects in an image, extracts one-dimensional spectra, and identifies the emission line feature. The main advantages of this method are: 1) to avoid subjectivity inherent to visual inspection used in past studies; and 2) the ability to obtain physical parameters without follow-up spectroscopy.

[ascl:1911.003]
OpenSPH: Astrophysical SPH and N-body simulations and interactive visualization tools

OpenSPH runs hydrodynamical and N-body simulations and was written for asteroid collisions and subsequent gravitational evolution. The code offers SPH and N-body solvers with several different equations of state and material rheologies. It is written in C++14 with a modular object-oriented design, focused on extensibility and maintainability, and it can be used either as a library or as a standalone graphical program that allows to set up the problem in a convenient graphical node editor. The graphical program further allows real-time visualization of the simulation, diagnostics and tools for analysis of the results.

[ascl:1502.002]
OpenOrb: Open-source asteroid orbit computation software

OpenOrb (OOrb) contains tools for rigorously estimating the uncertainties resulting from the inverse problem of computing orbital elements using scarce astrometry. It uses the least-squares method and also contains both Monte-Carlo (MC) and Markov-Chain MC versions of the statistical ranging method. Ranging obtains sampled, non-Gaussian orbital-element probability-density functions and is optimized for cases where the amount of astrometry is scarce or spans a relatively short time interval.

[ascl:1604.001]
OpenMHD: Godunov-type code for ideal/resistive magnetohydrodynamics (MHD)

OpenMHD is a Godunov-type finite-volume code for ideal/resistive magnetohydrodynamics (MHD). It is written in Fortran 90 and is parallelized by using MPI-3 and OpenMP. The code was originally developed for studying magnetic reconnection problems and has been made publicly available in the hope that others may find it useful.

[ascl:2104.009]
OpacityTool: Dust opacities for disk modeling

OpacityTool computes dust opacities for disc modelling; it includes a number of robust facts obtained from observations and theory and goes beyond astronomical silicates. It provides output files with κext(λ),κabs(λ),κsca(λ) as a function of wavelength λ, and the 6 scattering matrix elements for randomly oriented particles, F11(λ,θ), F12(λ,θ), F22(λ,θ), F33(λ, θ), F34(λ, θ), F44(λ, θ) as functions of wavelength and scattering angle θ.

This code is superseded by optool (ascl:2104.010).

[ascl:1904.024]
OoT: Out-of-Transit Light Curve Generator

OoT (Out-of-Transit) calculates the light curves and radial velocity signals due to a planet orbiting a star. It explicitly models the effects of tides, orbital motion. relativistic beaming, and reflection of the stars light by the planet. The code can also be used to model secondary eclipses.

[ascl:2403.014]
OneLoopBispectrum: Computation of the one-loop bispectrum of galaxies in redshift space

OneLoopBispectrum computes the one-loop bispectrum of galaxies in redshift space. It computes and simplifies the bispectrum kernels using Mathematica; this is cosmology-independent. The code also computes the full and flattened bispectrum templates, given the pre-computed integration kernels. OneLoopBispectrum uses Mathematica to read in and combine the bispectrum templates, and Python to interpolate and extract the one-loop bispectrum.

[ascl:1907.010]
OMNICAL: Redundant calibration code for low frequency radio interferometers

OMNICAL calibrates antennas in the redundant subset of the array. The code consists of two algorithms, a logarithmic method (logcal) and a linearized method (lincal). OMNICAL makes visibilities from physically redundant baselines agree with each other and also explicitly minimizes the variance within redundant visibilities.

[ascl:2212.020]
Omega: Photon equations of motion

Omega solves the photon equations of motion in the environment surrounding a black hole. This black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. The software offers numerous options, such as the geometrical setup of the accretion disk around the black hole (including no disk, band, slab, wedge, among others, the spin parameter of the central black hole, and the thickness of the accretion disk. Other options that can be set includ the azimuthal angle of the photon emission/reception, the poloidal angle of the photon emission/reception, and how far away or close to the system to look.

[ascl:1806.018]
OMEGA: One-zone Model for the Evolution of GAlaxies

OMEGA (One-zone Model for the Evolution of GAlaxies) calculates the global chemical evolution trends of galaxies. From an input star formation history, it uses SYGMA to create as a function of time multiple simple stellar populations with different masses, ages, and initial compositions. OMEGA offers several prescriptions for modeling the star formation efficiency and the evolution of galactic inflows and outflows. OMEGA is part of the NuGrid (ascl:1610.015) chemical evolution package.

[ascl:1906.015]
OIT: Nonconvex optimization approach to optical-interferometric imaging

In the context of optical interferometry, only undersampled power spectrum and bispectrum data are accessible, creating an ill-posed inverse problem for image recovery. Recently, a tri-linear model was proposed for monochromatic imaging, leading to an alternated minimization problem; in that work, only a positivity constraint was considered, and the problem was solved by an approximated Gauss–Seidel method.

The Optical-Interferometry-Trilinear code improves the approach on three fundamental aspects. First, the estimated image is defined as a solution of a regularized minimization problem, promoting sparsity in a fixed dictionary using either an l1 or a (re)weighted-l1 regularization term. Second, the resultant non-convex minimization problem is solved using a block-coordinate forward–backward algorithm. This algorithm is able to deal both with smooth and non-smooth functions, and benefits from convergence guarantees even in a non-convex context. Finally, the model and algorithm are generalized to the hyperspectral case, promoting a joint sparsity prior through an l2,1 regularization term.

[ascl:1601.004]
Odyssey: Ray tracing and radiative transfer in Kerr spacetime

Odyssey is a GPU-based General Relativistic Radiative Transfer (GRRT) code for computing images and/or spectra in Kerr metric describing the spacetime around a rotating black hole. Odyssey is implemented in CUDA C/C++. For flexibility, the namespace structure in C++ is used for different tasks; the two default tasks presented in the source code are the redshift of a Keplerian disk and the image of a Keplerian rotating shell at 340GHz. Odyssey_Edu, an educational software package for visualizing the ray trajectories in the Kerr spacetime that uses Odyssey, is also available.

[ascl:2002.005]
ODUSSEAS: Observing Dwarfs Using Stellar Spectroscopic Energy-Absorption Shapes

Antoniadis-Karnavas, A.; Sousa, S. G.; Delgado-Mena, E.; Santos, N. C.; Teixeira, G. D. C.; Neves, V.

ODUSSEAS (Observing Dwarfs Using Stellar Spectroscopic Energy-Absorption Shapes) uses machine learning to derive the Teff and [Fe/H] of M dwarf stars by using their optical spectra obtained by different spectrographs with different resolutions. The software uses the measurement of the pseudo equivalent widths for more than 4000 stellar absorption lines and the machine learning Python package scikit-learn (https://scikit-learn.org/stable/) to predict the stellar parameters.

[ascl:1810.010]
ODTBX: Orbit Determination Toolbox

ODTBX (Orbit Determination Toolbox) provides orbit determination analysis, advanced mission simulation, and analysis for concept exploration, proposal, early design phase, and/or rapid design center environments. The core ODTBX functionality is realized through a set of estimation commands that incorporate Monte Carlo data simulation, linear covariance analysis, and measurement processing at a generic level; its functions and utilities are combined in a flexible architecture to allow modular development of navigation algorithms and simulations. ODTBX is written in Matlab and Java.

[ascl:2211.018]
ODNet: Asteroid occultation detection convolutional neural network

Cazeneuve, Dorian; Marchis, Franck; Blaclard, Guillaume; Dalba, Paul A.; Martin, Victor; Asencioa, Joé

ODNet uses a convolutional neural network to examine frames of a given observation, using the flux of a targeted star along time, to detect occultations. This is particularly useful to reliably detect asteroid occultations for the Unistellar Network, which consists of 10,000 digital telescopes owned by citizen scientists that is regularly used to record asteroid occultations. ODNet is not costly in term of computing power, opening the possibility for embedding the code on the telescope directly. ODNet's models were developed and trained using TensorFlow version 2.4.

[ascl:1905.021]
ODEPACK: Ordinary differential equation solver library

ODEPACK solves for the initial value problem for ordinary differential equation systems. It consists of nine solvers, a basic solver called LSODE and eight variants of it: LSODES, LSODA, LSODAR, LSODPK, LSODKR, LSODI, LSOIBT, and LSODIS. The collection is suitable for both stiff and nonstiff systems. It includes solvers for systems given in explicit form, dy/dt = f(t,y), and also solvers for systems given in linearly implicit form, A(t,y) dy/dt = g(t,y). The ODEPACK solvers are written in standard Fortran and there are separate double and single precision versions. Each solver consists of a main driver subroutine having the same name as the solver and some number of subordinate routines. For each solver, there is also a demonstration program, which solves one or two simple problems in a somewhat self-checking manner.

[ascl:2101.012]
Octo-Tiger: HPX parallelized 3-D hydrodynamic code for stellar mergers

Marcello, Dominic C.; Shiber, Sagiv; De Marco, Orsola; Frank, Juhan; Clayton, Geoffrey C.; Motl, Patrick M.; Diehl, Patrick; Kaiser, Hartmut

Octo-Tiger models mass transfer in binary systems using a Cartesian adaptive mesh refinement grid. It simulates the evolution of star systems based on a modified fast multipole method (FMM) on adaptive octrees. The code takes shock heating into account and uses the dual energy formalism with an ideal gas equation of state; it also conserves linear and angular momenta to machine precision. Octo-Tiger is implemented in C++ and is parallelized using the High Performance ParalleX (HPX) runtime system.

[ascl:1010.048]
OCTGRAV: Sparse Octree Gravitational N-body Code on Graphics Processing Units

Octgrav is a very fast tree-code which runs on massively parallel Graphical Processing Units (GPU) with NVIDIA CUDA architecture. The algorithms are based on parallel-scan and sort methods. The tree-construction and calculation of multipole moments is carried out on the host CPU, while the force calculation which consists of tree walks and evaluation of interaction list is carried out on the GPU. In this way, a sustained performance of about 100GFLOP/s and data transfer rates of about 50GB/s is achieved. It takes about a second to compute forces on a million particles with an opening angle of $ heta approx 0.5$.

To test the performance and feasibility, we implemented the algorithms in CUDA in the form of a gravitational tree-code which completely runs on the GPU. The tree construction and traverse algorithms are portable to many-core devices which have support for CUDA or OpenCL programming languages. The gravitational tree-code outperforms tuned CPU code during the tree-construction and shows a performance improvement of more than a factor 20 overall, resulting in a processing rate of more than 2.8 million particles per second.

The code has a convenient user interface and is freely available for use.

[ascl:1812.018]
OctApps: Octave functions for continuous gravitational-wave data analysis

Wette, Karl; Prix, Reinhard; Keitel, David; Pitkin, Matthew; Dreissigacker, Christoph; Whelan, John T.; Leaci, Paola

The OctApps library provides various functions, written in Octave, for performing searches for the weak signatures of continuous gravitational waves from rapidly-rotating neutron stars amidst the instrumental noise of the LIGO and Virgo detectors.

[ascl:1901.002]
OCFit: Python package for fitting of O-C diagrams

OCFit fits and analyzes O-C diagrams using Genetic Algorithms and Markov chain Monte Carlo methods. The MC method is used to determine a very good estimation of errors of the parameters. Unlike some other fitting routines, OCFit does not need any initial values of fitted parameters. An intuitive graphic user interface is provided for ease of fitting, and nine common models of periodic O-C changes are included.

[ascl:1910.020]
OCD: O'Connell Effect Detector using push-pull learning

OCD (O'Connell Effect Detector) detects eclipsing binaries that demonstrate the O'Connell Effect. This time-domain signature extraction methodology uses a supporting supervised pattern detection algorithm. The methodology maps stellar variable observations (time-domain data) to a new representation known as Distribution Fields (DF), the properties of which enable efficient handling of issues such as irregular sampling and multiple values per time instance. Using this representation, the code applies a metric learning technique directly on the DF space capable of specifically identifying the stars of interest; the metric is tuned on a set of labeled eclipsing binary data from the Kepler survey, targeting particular systems exhibiting the O’Connell Effect. This code is useful for large-scale data volumes such as that expected from next generation telescopes such as LSST.

[submitted]
obsplanning - a set of python utilities to aid in planning astronomical observations

Obsplanning is a suite of tools to help plan astronomical observations from ground-based observatories, for traditional single-site as well as multi-station (VLBI) observing. Conveniently determine observability of objects in the sky from your observatory, and produce plots to help you prepare for your observations over the course of a session. Celestial source coordinates (including solar system objects) can be queried or created, and transformed. Calibrator or reference sources can be selected by proximity, and slew order can be optimized to save valuable telescope time. Plots and visualizations can be easily made to chart source elevation and transits, source proximity to the Sun and Moon, concurrent 'up time' of sources at multiple sites (for VLBI or tandem observations), 'dark time' at a telescope site for a given year, finder plots made from real images (with options to query online databases), and more.

[submitted]
ObsPlanner

Simple program for planning and managing astronomical observations as observational diary or logs.

[ascl:1307.008]
Obit: Radio Astronomy Data Handling

Obit is a group of software packages for handling radio astronomy data, especially interferometric and single dish OTF imaging. Obit is primarily an environment in which new data processing algorithms can be developed and tested but which can also be used for production processing of a certain range of scientific problems. The package supports both prepackaged, compiled tasks and a python interface to the major class functionality to allow rapid prototyping using python scripts; it allows access to multiple disk--resident data formats, in particular access to either AIPS disk data or FITS files. Obit applications are interoperable with Classic AIPS and the ObitTalk python interface gives access to AIPS tasks as well as Obit libraries and tasks.

[ascl:1608.012]
OBERON: OBliquity and Energy balance Run on N-body systems

OBERON (OBliquity and Energy balance Run on N-body systems) models the climate of Earthlike planets under the effects of an arbitrary number and arrangement of other bodies, such as stars, planets and moons. The code, written in C++, simultaneously computes N body motions using a 4th order Hermite integrator, simulates climates using a 1D latitudinal energy balance model, and evolves the orbital spin of bodies using the equations of Laskar (1986a,b).

[ascl:1408.019]
O_{2}scl: Object-oriented scientific computing library

O_{2}scl is an object-oriented library for scientific computing in C++ useful for solving, minimizing, differentiating, integrating, interpolating, optimizing, approximating, analyzing, fitting, and more. Many classes operate on generic function and vector types; it includes classes based on GSL and CERNLIB. O_{2}scl also contains code for computing the basic thermodynamic integrals for fermions and bosons, for generating almost all of the most common equations of state of nuclear and neutron star matter, and for solving the TOV equations. O_{2}scl can be used on Linux, Mac and Windows (Cygwin) platforms and has extensive documentation.

[ascl:2112.019]
O'TRAIN: Optical TRAnsient Identification NEtwork

The O'TRAIN package identifies transients in astronomical images based on a Convolutional Neural Network (CNN). It works on images from different telescopes and, through the use of Docker, can be deployed on different operating systems. O'TRAIN uses image cutouts containing real and false transients provided by the user to train a CNN algorithm implemented with Keras. Built-in diagnostics help to characterize the accuracy of the training, and a trained model is used to classify any new cutouts.

[ascl:1712.006]
Nyx: Adaptive mesh, massively-parallel, cosmological simulation code

Nyx code solves equations of compressible hydrodynamics on an adaptive grid hierarchy coupled with an N-body treatment of dark matter. The gas dynamics in Nyx use a finite volume methodology on an adaptive set of 3-D Eulerian grids; dark matter is represented as discrete particles moving under the influence of gravity. Particles are evolved via a particle-mesh method, using Cloud-in-Cell deposition/interpolation scheme. Both baryonic and dark matter contribute to the gravitational field. In addition, Nyx includes physics for accurately modeling the intergalactic medium; in optically thin limits and assuming ionization equilibrium, the code calculates heating and cooling processes of the primordial-composition gas in an ionizing ultraviolet background radiation field.

[ascl:2202.002]
NWelch: Spectral analysis of time series with nonuniform observing cadence

NWelch uses Welch's method to estimate the power spectra, complex cross-spectrum, magnitude-squared coherence, and phase spectrum of bivariate time series with nonuniform observing cadence. For univariate time series, users can apply the Welch's power spectrum estimator or compute a nonuniform fast Fourier transform-based periodogram. Options include tapering in the time domain and computing bootstrap false alarm levels. Users may choose standard 50%-overlapping Welch's segments or apply a custom-made segmentation scheme. NWelch was designed for Doppler planet searches but may be applied to any type of time series.

[ascl:2102.014]
nway: Bayesian cross-matching of astronomical catalogs

nway is a source cross-matching tool for arbitrarily many astronomical catalogs. It features Bayesian match probabilities based on astronomical sky coordinates (RA, DEC), works with arbitrarily many catalogs, and can handle varying errors. nway can also incorporate additional prior information, such as the magnitude or color distributions of the sources to match, and works accurately and fast in small areas and all-sky catalogs.

[ascl:2306.044]
nuSpaceSim: Cosmic neutrino simulation

nuSpaceSim simulates upward-going extensive air showers caused by neutrino interactions with the atmosphere. It is an end-to-end, neutrino flux to space-based signal detection, modeling tool for the design of sub-orbital and space-based neutrino detection experiments. This comprehensive suite of modeling packages accepts an experimental design input and then models the experiment's sensitivity to both the diffuse, cosmogenic neutrino flux as well as astrophysical neutrino transient events, such as that postulated from binary neutron star (BNS) mergers. nuSpaceSim calculates the tau neutrino acceptance for the Optical Cherenkov technique; tau propagation is interpolated using included data tables from nupyprop (ascl:2306.044). The simulation is parameterized by an input XML configuration file, with settings for detector characteristics and global parameters; nuSpaceSim also provides a python API for programmatic access.

[ascl:1908.011]
NuRadioMC: Monte Carlo simulation package for radio neutrino detectors

Glaser, Christian; García-Fernández, Daniel; Nelles, Anna; Alvarez-Muñiz, Jaime; Barwick, Steven W.; Besson, Dave Z.; Clark, Brian A.; Connolly, Amy; Deaconu, Cosmin; de Vries, Krijn; Hanson, Jordan C.; Hokanson-Fasig, Ben; Lahmann, R.; Latif, Uzair; Kleinfelder, Stuart A.; Persichilli, Christopher; Pan, Yue; Pfender, Carl; Plaisier, Ilse; Seckel, Dave Torres, Jorge; Toscano, Simona; van Eijndhoven, Nick; Vieregg, Abigail; Welling, Christoph; Winchen, Tobias; Wissel, Stephanie A.

NuRadioMC simulates ultra-high energy neutrino detectors that rely on the radio detection method, which exploits the radio emission generated in the electromagnetic component of a particle shower following a neutrino interaction. The code simulates the neutrino interaction in a medium, subsequent Askaryan radio emission, propagation of the radio signal to the detector and the detector response. NuRadioMC is a Monte Carlo framework that combines flexibility in detector design with user-friendliness. It includes an event generator, improved modeling of the radio emission, a revisited approach to signal propagation, and increased flexibility and precision in the detector simulation.

[ascl:2306.045]
nuPyProp: Propagate neutrinos through the earth

Garg, Diksha; Patel, Sameer; Reno, Mary Hall; Reustle, Alexander; Akaike, Yosui; Anchordoqui, Luis A.; Bergman, Douglas R.; Buckland, Isaac; Cummings, Austin L.; Eser, Johannes; Garcia, Fred; Guépin, Claire; Heibges, Tobias; Ludwig, Andrew; Krizmanic, John F.; Mackovjak, Simon; Mayotte, Eric; Mayotte, Sonja; Olinto, Angela V.; Paul, Thomas C.; Romero-Wolf, Andrés; Sarazin, Frédéric; Venters, Tonia M.; Wiencke, Lawrence; Wissel, Stephanie

nuPyProp simulates tau neutrino and muon neutrino interactions in the Earth and predicts the spectrum of the τ-leptons and muons that emerge. The code produces tables of charged lepton exit probabilities and energies that can be used directly or as inputs to nuSpaceSim (ascl:2306.043), which is designed to simulate optical and radio signals from extensive air showers induced by the emerging charged leptons.

[ascl:1610.015]
NuPyCEE: NuGrid Python Chemical Evolution Environment

The NuGrid Python Chemical Evolution Environment (NuPyCEE) simulates the chemical enrichment and stellar feedback of stellar populations. It contains three modules. The Stellar Yields for Galactic Modeling Applications module (SYGMA) models the enrichment and feedback of simple stellar populations which can be included in hydrodynamic simulations and semi-analytic models of galaxies. It is the basic building block of the One-zone Model for the Evolution of GAlaxies (OMEGA, ascl:1806.018) module which models the chemical evolution of galaxies such as the Milky Way and its dwarf satellites. The STELLAB (STELLar ABundances) module provides a library of observed stellar abundances useful for comparing predictions of SYGMA and OMEGA.

[ascl:1408.013]
NumCosmo: Numerical Cosmology

NumCosmo is a free software C library whose main purposes are to test cosmological models using observational data and to provide a set of tools to perform cosmological calculations. The software implements three different probes: cosmic microwave background (CMB), supernovae type Ia (SNeIa) and large scale structure (LSS) information, such as baryonic acoustic oscillations (BAO) and galaxy cluster abundance. The code supports a joint analysis of these data and the parameter space can include cosmological and phenomenological parameters. NumCosmo matter power spectrum and CMB codes were written independent of other implementations such as CMBFAST (ascl:9909.004), CAMB (ascl:1102.026), etc.

The library structure simplifies the inclusion of non-standard cosmological models. Besides the functions related to cosmological quantities, this library also implements mathematical and statistical tools. The former were developed to enable the inclusion of other probes and/or theoretical models and to optimize the codes. The statistical framework comprises algorithms which define likelihood functions, minimization, Monte Carlo, Fisher Matrix and profile likelihood methods.

[ascl:1601.014]
Nulike: Neutrino telescope likelihood tools

Nulike is software for including full event-level information in likelihood calculations for neutrino telescope searches for dark matter annihilation. It includes both angular and spectral information about neutrino events as well as their total number, and can be used for single models without reference to the rest of a parameter space.

[ascl:1904.030]
nudec_BSM: Neutrino Decoupling Beyond the Standard Model

nudec_BSM uses a simplified approach to solve for the neutrino decoupling, allowing one to capture the time dependence of the process while accounting for all possible interactions that can alter it.

[ascl:1602.008]
NuCraft: Oscillation probabilities for atmospheric neutrinos calculator

NuCraft calculates oscillation probabilities for atmospheric neutrinos, taking into account matter effects and the Earth's atmosphere, and supports an arbitrary number of sterile neutrino flavors with easily configurable continuous Earth models. Continuous modeling of the Earth instead of the often-used approximation of four layers with constant density and consideration of the smearing of baseline lengths due to the variable neutrino production heights in Earth's atmosphere each lead to deviations of 10% or more for conventional neutrinos between 1 and 10 GeV.

[ascl:1609.009]
NSCool: Neutron star cooling code

NSCool is a 1D (i.e., spherically symmetric) neutron star cooling code written in Fortran 77. The package also contains a series of EOSs (equation of state) to build stars, a series of pre-built stars, and a TOV (Tolman- Oppenheimer-Volkoff) integrator to build stars from an EOS. It can also handle “strange stars” that have a huge density discontinuity between the quark matter and the covering thin baryonic crust. NSCool solves the heat transport and energy balance equations in whole GR, resulting in a time sequence of temperature profiles (and, in particular, a Teff - age curve). Several heating processes are included, and more can easily be incorporated. In particular it can evolve a star undergoing accretion with the resulting deep crustal heating, under a steady or time-variable accretion rate. NSCool is robust, very fast, and highly modular, making it easy to add new subroutines for new processes.

[ascl:2012.002]
NSCG: NOIRLab Source Catalog Generator

The NOIRLab Source Catalog Generator generates the NOIRLab Source Catalog (NSC), a catalog of all publicly available imagining data in the NOIRLab Astro Data Archive. The second data release (DR2) of the archive contains over 3.9 billion unique objects, 68 billion individual source measurements, covers 35,000 square degrees of the sky, has depths of 23rd magnitude in most broadband filters with 1-2% photometric precision, and astrometric accuracy of 7 mas. NSCG is written in Python and IDL. Three main steps generate the NSC: (1) Source Extractor (ascl:1010.064) is used to detect and measure sources in individual images; (2) astrometrics are calibrated with Gaia DR2 and photometric calibration using large public photometric catalogs such as Pan-STARRS1 and ATLAS-Refcat2; and, (3) measurements are clustered into unique objects, averaging photometric and morphological properties, and calculating proper motions and photometric variability indices.

[ascl:1807.025]
NRPy+: Code generator for Numerical Relativity

NRPy+ (Python-based Code generation for Numerical Relativity and Beyond) generates highly-optimized C code from complex tensorial expressions input in Einstein-like notation. NRPy+ uses SymPy as its computer algebra system backend. It is part of the NRPy+/SENR numerical relativity code package for solving Einstein's equations of general relativity to model compact objects at about 1/100 the cost in memory of more traditional, AMR-based numerical relativity codes, thus allowing desktop computers to be used for gravitational wave astrophysics.

[ascl:2108.012]
NRDD_constraints: Dark Matter interaction with the Standard Model exclusion plot calculator

The NRDD_constraints tool provides simple interpolating functions written in Python that return the most constraining limit on the dark matter-nucleon scattering cross section for a list of non-relativistic effective operators. The package contains four files: the main code, NRDD_constraints.py; a simple driver, NRDD_constraints-example.py; and two data files, NRDD_data1.npy and NRDD_data2.npy

[ascl:1804.015]
NR-code: Nonlinear reconstruction code

NR-code applies nonlinear reconstruction to the dark matter density field in redshift space and solves for the nonlinear mapping from the initial Lagrangian positions to the final redshift space positions; this reverses the large-scale bulk flows and improves the precision measurement of the baryon acoustic oscillations (BAO) scale.

[ascl:1705.014]
NPTFit: Non-Poissonian Template Fitting

NPTFit is a specialized Python/Cython package that implements Non-Poissonian Template Fitting (NPTF), originally developed for characterizing populations of unresolved point sources. It offers fast evaluation of likelihoods for NPTF analyses and has an easy-to-use interface for performing non-Poissonian (as well as standard Poissonian) template fits using MultiNest (ascl:1109.006) or other inference tools. It allows inclusion of an arbitrary number of point source templates, with an arbitrary number of degrees of freedom in the modeled flux distribution, and has modules for analyzing and plotting the results of an NPTF.

[ascl:2201.014]
nProFit: n-Profile Fitting tool

nProFit analyzes surface brightness profiles. It obtains the best-fit structural, scale, and shape parameters of star clusters in Hubble Space Telescope images of nearby galaxies. The code fits dynamical models and can derive physically-relevant parameters. Among these are central volume and luminosity densities, total masses and luminosities, central velocity dispersions, core radius, half-light radius, tidal radius, and binding energy.

Previous12345678910111213141516171819202122232425262728**29**303132333435363738394041424344454647484950515253545556575859606162636465666768697071Next

Would you like to view a random code?