ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:1507.011] FAT: Fully Automated TiRiFiC

FAT (Fully Automated TiRiFiC) is an automated procedure that fits tilted-ring models to Hi data cubes of individual, well-resolved galaxies. The method builds on the 3D Tilted Ring Fitting Code (TiRiFiC, ascl:1208.008). FAT accurately models the kinematics and the morphologies of galaxies with an extent of eight beams across the major axis in the inclination range 20°-90° without the need for priors such as disc inclination. FAT's performance allows us to model the gas kinematics of many thousands of well-resolved galaxies, which is essential for future HI surveys, with the Square Kilometre Array and its pathfinders.

[ascl:1711.017] FATS: Feature Analysis for Time Series

FATS facilitates and standardizes feature extraction for time series data; it quickly and efficiently calculates a compilation of many existing light curve features. Users can characterize or analyze an astronomical photometric database, though this library is not necessarily restricted to the astronomical domain and can also be applied to any kind of time series data.

[ascl:2204.010] FBCTrack: Fragmentation and bulk composition tracking

The fragmentation and bulk composition tracking package contains two codes. The fragmentation code models fragmentation in collisions for the C version of REBOUND (ascl:1110.016). This code requires setting two global parameters. It automatically produces a collision report that details the time of every collision, the bodies involved, how the collision was resolved, and how many fragments were produced; collision outcomes are assigned a numerical value. The bulk composition tracking code tracks the composition change as a function of mass exchange for bodies with a homogenous composition. It is a post-processing code that works in conjunction with the fragmentation code, and requires the collision report generated by the fragmentation code.

[ascl:1712.011] FBEYE: Analyzing Kepler light curves and validating flares

FBEYE, the "Flares By-Eye" detection suite, is written in IDL and analyzes Kepler light curves and validates flares. It works on any 3-column light curve that contains time, flux, and error. The success of flare identification is highly dependent on the smoothing routine, which may not be suitable for all sources.

[ascl:2302.015] FCFC: C toolkit for computing correlation functions from pair counts

FCFC (Fast Correlation Function Calculator) computes correlation functions from pair counts. It supports the isotropic 2-point correlation function, anisotropic 2PCF, 2-D 2PCF, and 2PCF Legendre multipoles, among others. Written in C, FCFC takes advantage of three parallelisms that can be used simultaneously, distributed-memory processes via Message Passing Interface (MPI), shared-memory threads via Open Multi-Processing (OpenMP), and single instruction, multiple data (SIMD).

[ascl:1505.014] FCLC: Featureless Classification of Light Curves

FCLC (Featureless Classification of Light Curves) software describes the static behavior of a light curve in a probabilistic way. Individual data points are converted to densities and consequently probability density are compared instead of features. This gives rise to an independent classification which can corroborate the usefulness of the selected features.

[ascl:1806.027] fcmaker: Creating ESO-compliant finding charts for Observing Blocks on p2

fcmaker creates astronomical finding charts for Observing Blocks (OBs) on the p2 web server from the European Southern Observatory (ESO). It automates the creation of ESO-compliant finding charts for Service Mode and/or Visitor Mode OBs at the Very Large Telescope (VLT). The design of the fcmaker finding charts, based on an intimate knowledge of VLT observing procedures, is fine-tuned to best support night time operations. As an automated tool, fcmaker also allows observers to independently check visually, for the first time, the observing sequence coded inside an OB. This includes, for example, the signs of telescope and position angle offsets.

[ascl:1705.012] fd3: Spectral disentangling of double-lined spectroscopic binary stars

The spectral disentangling technique can be applied on a time series of observed spectra of a spectroscopic double-lined binary star (SB2) to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. fd3 disentangles the spectra of SB2 stars, capable also of resolving the possible third companion. It performs the separation of spectra in the Fourier space which is faster, but in several respects less versatile than the wavelength-space separation. (Wavelength-space separation is implemented in the twin code CRES.) fd3 is written in C and is designed as a command-line utility for a Unix-like operating system. fd3 is a new version of FDBinary (ascl:1705.011), which is now deprecated.

[ascl:1705.011] FDBinary: A tool for spectral disentangling of double-lined spectroscopic binary stars

FDBinary disentangles spectra of SB2 stars. The spectral disentangling technique can be applied on a time series of observed spectra of an SB2 to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. The code is written in C and is designed as a command-line utility for a Unix-like operating system. FDBinary uses the Fourier-space approach in separation of composite spectra. This code has been replaced with the newer fd3 (ascl:1705.012).

[ascl:1606.011] FDIPS: Finite Difference Iterative Potential-field Solver

FDIPS is a finite difference iterative potential-field solver that can generate the 3D potential magnetic field solution based on a magnetogram. It is offered as an alternative to the spherical harmonics approach, as when the number of spherical harmonics is increased, using the raw magnetogram data given on a grid that is uniform in the sine of the latitude coordinate can result in inaccurate and unreliable results, especially in the polar regions close to the Sun. FDIPS is written in Fortran 90 and uses the MPI library for parallel execution.

[ascl:1604.011] FDPS: Framework for Developing Particle Simulators

FDPS provides the necessary functions for efficient parallel execution of particle-based simulations as templates independent of the data structure of particles and the functional form of the interaction. It is used to develop particle-based simulation programs for large-scale distributed-memory parallel supercomputers. FDPS includes templates for domain decomposition, redistribution of particles, and gathering of particle information for interaction calculation. It uses algorithms such as Barnes-Hut tree method for long-range interactions; methods to limit the calculation to neighbor particles are used for short-range interactions. FDPS reduces the time and effort necessary to write a simple, sequential and unoptimized program of O(N^2) calculation cost, and produces compiled programs that will run efficiently on large-scale parallel supercomputers.

[ascl:1806.001] feets: feATURE eXTRACTOR FOR tIME sERIES

feets characterizes and analyzes light-curves from astronomical photometric databases for modelling, classification, data cleaning, outlier detection and data analysis. It uses machine learning algorithms to determine the numerical descriptors that characterize and distinguish the different variability classes of light-curves; these range from basic statistical measures such as the mean or standard deviation to complex time-series characteristics such as the autocorrelation function. The library is not restricted to the astronomical field and could also be applied to any kind of time series. This project is a derivative work of FATS (ascl:1711.017).

[ascl:2110.018] FEniCS: Computing platform for solving partial differential equations

FEniCS solves partial differential equations (PDEs) and enables users to quickly translate scientific models into efficient finite element code. With the high-level Python and C++ interfaces to FEniCS, it is easy to get started, but FEniCS offers also powerful capabilities for more experienced programmers. FEniCS runs on a multitude of platforms ranging from laptops to high-performance clusters, and each component of the FEniCS platform has been fundamentally designed for parallel processing. This framework allows for rapid prototyping of finite element formulations and solvers on laptops and workstations, and the same code may then be deployed on large high-performance computers.

[ascl:1203.004] FERENGI: Full and Efficient Redshifting of Ensembles of Nearby Galaxy Images

Bandpass shifting and the (1+z)5 surface brightness dimming (for a fixed width filter) make standard tools for the extraction of structural parameters of galaxies wavelength dependent. If only few (or one) observed high-res bands exist, this dependence has to be corrected to make unbiased statements on the evolution of structural parameters or on galaxy subsamples defined by morphology. FERENGI artificially redshifts low-redshift galaxy images to different redshifts by applying the correct cosmological corrections for size, surface brightness and bandpass shifting. A set of artificially redshifted galaxies in the range 0.1<z<1.1 using a set of ~100 SDSS low-redshift (v<7000 km s-1) images as input has been created to use as a training set of realistic images of galaxies of diverse morphologies and a large range of redshifts for the GEMS and COSMOS galaxy evolution projects. This training set allows other studies to investigate and quantify the effects of cosmological redshift on the determination of galaxy morphologies, distortions, and other galaxy properties that are potentially sensitive to resolution, surface brightness, and bandpass issues. The data sets are also available for download from the FERENGI website.

[ascl:2201.008] fermi-gce-flows: Infer the Galactic Center gamma-ray excess

fermi-gce-flows uses a machine learning-based technique to characterize the contribution of modeled components, including unresolved point sources, to the GCE. It can perform posterior parameter estimation while accounting for pixel-to-pixel spatial correlations in the gamma-ray map. On application to Fermi data, the method generically attributes a smaller fraction of the GCE flux to unresolved point source-like emission when compared to traditional approaches.

[ascl:1812.006] Fermipy: Fermi-LAT data analysis package

Fermipy facilitates analysis of data from the Large Area Telescope (LAT) with the Fermi Science Tools. It is built on the pyLikelihood interface of the Fermi Science Tools and provides a set of high-level tools for performing common analysis tasks, including data and model preparation with the gt-tools, extracting a spectral energy distribution (SED) of a source, and generating TS and residual maps for a region of interest. Fermipy also finds new source candidates and can localize a source or fit its spatial extension. The package uses a configuration-file driven workflow in which the analysis parameters (data selection, IRFs, and ROI model) are defined in a YAML configuration file. Analysis is executed through a python script that calls the methods of GTAnalysis to perform different analysis operations.

[ascl:1905.011] Fermitools: Fermi Science Tools

Fermi Science Tools is a suite of tools for the analysis of both the Large-Area Telescope (LAT) and the Gamma-ray Burst Monitor (GBM) data, including point source analysis for generating maps, spectra, and light curves, pulsar timing analysis, and source identification.

[ascl:2301.016] FERRE: Match physical models to measurements

FERRE matches physical models to observed data, taking a set of observations and identifying the model parameters that best reproduce the data, in a chi-squared sense. It solves the common problem of having numerical parametric models that are costly to evaluate and need to be used to interpret large data sets. FERRE provides flexibility to search for all model parameters, or hold constant some of them while searching for others. The code is written to be truly N-dimensional and fast. Model predictions are to be given as an array whose values are a function of the model parameters, i.e., numerically. FERRE holds this array in memory, or in a direct-access binary file, and interpolates in it. The code returns, in addition to the optimal set of parameters, their error covariance, and the corresponding model prediction. The code is written in FORTRAN90.

[ascl:2005.014] FETCH: Fast Extragalactic Transient Candidate Hunter

FETCH (Fast Extragalactic Transient Candidate Hunter) provides real-time classification of candidates from single pulse search pipelines. The package takes in a candidate file of frequency-time and DM-time data and, for each candidate and choice of model, provides the probability that the candidate is an FRB. FETCH also provides a framework for fine-tuning the models to further improve its performance for particular backends.

[ascl:1208.011] Fewbody: Numerical toolkit for simulating small-N gravitational dynamics

Fewbody is a numerical toolkit for simulating small-N gravitational dynamics. It is a general N-body dynamics code, although it was written for the purpose of performing scattering experiments, and therefore has several features that make it well-suited for this purpose. Fewbody uses the 8th-order Runge-Kutta Prince-Dormand integration method with 9th-order error estimate and adaptive timestep to advance the N-body system forward in time. It integrates the usual formulation of the N-body equations in configuration space, but allows for the option of global pairwise Kustaanheimo-Stiefel (K-S) regularization (Heggie 1974; Mikkola 1985). The code uses a binary tree algorithm to classify the N-body system into a set of independently bound hierarchies, and performs collisions between stars in the “sticky star” approximation. Fewbody contains a collection of command line utilities that can be used to perform individual scattering and N-body interactions, but is more generally a library of functions that can be used from within other codes.

[ascl:2005.006] FFANCY: Fast Folding Algorithm for pulsar searching

FFANCY uses the Fast Folding Algorithm (FFA) on a distributed-computing framework to search for pulsars in time-domain series data. This enables the algorithm to be applied to all-sky blind pulsar surveys. The package runs an implementation of the FFA on real or simulated pulsar time series data in either SIGPROC (ascl:1107.016) or PRETSO (ascl:1107.017) format with a choice of additional algorithms to be used in the evaluation of each folded profile and outputs a periodogram along with other output threads used for testing. It also contains routines that convert the periodogram output into a list of pulsar candidates with options for candidate grouping and harmonic matching, generate simulated pulsar profiles for use in testing profile evaluation algorithms independent of the FFA, provide basic statistics for the folded profiles produced by progeny, test individual profiles using profiles produced by progeny, and other complementary functions.

[ascl:2208.010] FFD: Flare Frequency Distribution

FFD (Flare Frequency Distribution) fits power-laws to FFDs. FFDs relate the frequency (i.e., occurrence rate) of flares to their energy, peak flux, photometric equivalent width, or other parameters. This module was created to handle disparate datasets between which the flare detection limit varies; in essence, the number of flares detected is treated as following a Poisson distribution while the flare energies are treated as following a power law.

[ascl:1911.022] FFTLog-and-beyond: Generalized FFTLog algorithm

FFTLog-and-beyond takes the FFTLog algorithm for single-Bessel integrals and generalizes it for integrals containing a derivative of the Bessel function to solve the non-Limber integrals. The full non-Limber angular power spectrum integral is simplified by noting the small contribution from unequal-time nonlinear terms; this significantly reduces the computation and avoids the double-Bessel integral. The original FFTLog algorithm is also extended to compute integrals containing derivatives of Bessel functions, which can be used to efficiently compute angular power spectra including redshift-space distortions (RSD) and Doppler effects. C and Python versions of the code are available.

[ascl:1512.017] FFTLog: Fast Fourier or Hankel transform

FFTLog is a set of Fortran subroutines that compute the fast Fourier or Hankel (= Fourier-Bessel) transform of a periodic sequence of logarithmically spaced points. FFTLog can be regarded as a natural analogue to the standard Fast Fourier Transform (FFT), in the sense that, just as the normal FFT gives the exact (to machine precision) Fourier transform of a linearly spaced periodic sequence, so also FFTLog gives the exact Fourier or Hankel transform, of arbitrary order m, of a logarithmically spaced periodic sequence.

[ascl:1201.015] FFTW: Fastest Fourier Transform in the West

FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST).

Benchmarks performed on a variety of platforms show that FFTW's performance is typically superior to that of other publicly available FFT software, and is even competitive with vendor-tuned codes. In contrast to vendor-tuned codes, however, FFTW's performance is portable: the same program will perform well on most architectures without modification.

The FFTW library is required by other codes such as StarCrash (ascl:1010.074) and Hammurabi (ascl:1201.014).

[ascl:2307.021] FGBuster: Parametric component separation for Cosmic Microwave Background observations

FGBuster (ForeGroundBuster) separates frequency maps into component maps and forecasts component separation both when the model is correct and when it is incorrect. FGBuster can be used for SED evaluation, intermediate component separation, multi-resolution separation, and forecasting, among other tasks.

[ascl:1909.014] fgivenx: Functional posterior plotter

fgivenx plots a predictive posterior of a function, dependent on sampled parameters, for a Bayesian posterior Post(theta|D,M) described by a set of posterior samples {theta_i}~Post. If there is a function parameterized by theta y=f(x;theta), this script produces a contour plot of the conditional posterior P(y|x,D,M) in the (x,y) plane.

[ascl:2205.014] FHD: Fast Holographic Deconvolution

FHD is an open-source imaging algorithm for radio interferometers and is written in IDL. The three main use-cases for FHD are efficient image deconvolution for general radio astronomy, fast-mode Epoch of Reionization analysis, and simulation. FHD inputs beam models, calibration files, and sky model catalogs and requires input data to be in uvfits format.

[ascl:1603.014] fibmeasure: Python/Cython module to find the center of back-illuminated optical fibers in metrology images

fibmeasure finds the precise locations of the centers of back-illuminated optical fibers in images. It was developed for astronomical fiber positioning feedback via machine vision cameras and is optimized for high-magnification images where fibers appear as resolvable circles. It was originally written during the design of the WEAVE pick-and-place fiber positioner for the William Herschel Telescope.

[ascl:1111.013] FIBRE-pac: FMOS Image-based Reduction Package

The FIBRE-pac (FMOS image-based reduction package) is an IRAF-based reduction tool for the fiber multiple-object spectrograph (FMOS) of the Subaru telescope. To reduce FMOS images, a number of special techniques are necessary because each image contains about 200 separate spectra with airglow emission lines variable in spatial and time domains, and with complicated throughput patterns for the airglow masks. In spite of these features, almost all of the reduction processes except for a few steps are carried out automatically by scripts in text format making it easy to check the commands step by step. Wavelength- and flux-calibrated images together with their noise maps are obtained using this reduction package.

[ascl:2202.012] fiducial_flare: Spectra and lightcurves of a standardized far ultraviolet flare

fiducial_flare generates a reasonable approximation of the UV emission of M dwarf stars over a single flare or a series of them. The simulated radiation is resolved in both wavelength and time. The intent is to provide consistent input for applications requiring time-dependent stellar UV radiation fields that balances simplicity with realism, namely for simulations of exoplanet atmospheres.

[ascl:1307.004] FieldInf: Field Inflation exact integration routines

FieldInf is a collection of fast modern Fortran routines for computing exactly the background evolution and primordial power spectra of any single field inflationary models. It implements reheating without any assumptions through the "reheating parameter" R allowing robust inflationary parameter estimations and inference on the reheating energy scale. The underlying perturbation code actually deals with N fields minimally-coupled and/or non-minimally coupled to gravity and works for flat FLRW only.

[ascl:1708.009] FIEStool: Automated data reduction for FIber-fed Echelle Spectrograph (FIES)

FIEStool automatically reduces data obtained with the FIber-fed Echelle Spectrograph (FIES) at the Nordic Optical Telescope, a high-resolution spectrograph available on a stand-by basis, while also allowing the basic properties of the reduction to be controlled in real time by the user. It provides a Graphical User Interface and offers bias subtraction, flat-fielding, scattered-light subtraction, and specialized reduction tasks from the external packages IRAF (ascl:9911.002) and NumArray. The core of FIEStool is instrument-independent; the software, written in Python, could with minor modifications also be used for automatic reduction of data from other instruments.

[ascl:1203.013] Figaro: Data Reduction Software

Figaro (sometimes referred to as "standalone Figaro") is a data reduction system that originated at Caltech and whose development continued at the Anglo-Australian Observatory. Although it is intended to be able to deal with any sort of data, almost all its applications to date are geared towards processing optical and infrared data. Figaro uses hierarchical data structures to provide flexibility in its data file formats. Figaro was originally written to run under DEC's VMS operating system, but is now available both for VAX/VMS (by special request) and for various flavors of UNIX including Linux and MacOS.

A variant of Figaro (ascl:1411.022) is incorporated into the Starlink package (ascl:1110.012).

[ascl:1608.009] FilFinder: Filamentary structure in molecular clouds

FilFinder extracts and analyzes filamentary structure in molecular clouds. In particular, it is capable of uniformly extracting structure over a large dynamical range in intensity. It returns the main filament properties: local amplitude and background, width, length, orientation and curvature. FilFinder offers additional tools to, for example, create a filament-only image based on the properties of the radial fits. The resulting mask and skeletons may be saved in FITS format, and property tables may be saved as a CSV, FITS or LaTeX table.

[ascl:1602.007] FilTER: Filament Trait-Evaluated Reconstruction

FilTER (Filament Trait-Evaluated Reconstruction) post-processes output from DisPerSE (ascl:1302.015 ) to produce a set of filaments that are well-defined and have measured properties (e.g. width), then cuts the profiles, fits and assesses them to reconstruct new filaments according to defined criteria.

[ascl:2202.016] Find_Orb: Orbit determination from observations

Find_Orb takes a set of observations of an asteroid, comet, or natural or artificial satellite given in the MPC (Minor Planet Center) format, the ADES astrometric format, and/or the NEODyS or AstDyS formats, and finds the corresponding orbit.

[ascl:2210.004] Finder_charts: Create finder charts from image data of various sky surveys

Finder_charts creates multi-band finder charts from image data of various partial- and all-sky surveys such as DSS, 2MASS, WISE, UKIDSS, VHS, Pan-STARRS, and DES. It also creates a WISE time series of image data acquired between 2010 and 2021. All images are reprojected so that north is up and east is to the left. The resulting finder charts can be overplotted with corresponding catalog positions. All catalog entries within the specified field of view can be saved in a variety of formats, including ipac, csv, and tex, as can the finder charts in png, pdf, eps, and other common graphics formats. Finder_charts consists of a single Python module, which depends only on well-known packages, making it easy to install.

[ascl:2004.013] Finesse: Frequency domain INterfErometer Simulation SoftwarE

Finesse is a numeric simulation for laser interferometers and models parametric instabilities, easily providing the required mechanical-to-optical transfer functions in imperfect and arbitrary interferometer configurations using Hermite-Gaussian beams. The code has been used to apply limits to the number and type of higher order modes used in simulation and investigate the potential use of higher order Laguerre-Gauss modes to reduce thermal noise in future gravitational wave detector designs. The PyKat wrapper (ascl:2004.014) helps automate complex Finesse tasks.

[ascl:1808.006] Fips: An OpenGL based FITS viewer

FIPS is a cross-platform FITS viewer with a responsive user interface. Unlike other FITS viewers, FIPS uses GPU hardware via OpenGL to provide functionality such as zooming, panning and level adjustments. OpenGL 2.1 and later is supported. FIPS supports all 2D image formats except floating point formats on OpenGL 2.1. FITS image extension has basic limited support.

[ascl:2202.006] FIRE Studio: Movie making utilities for the FIRE simulations

FIRE Studio is a Python interface for C libraries that project Smoothed Particle Hydrodynamic (SPH) datasets. These C libraries can, in principle, be applied to any SPH dataset; the Python interface is specialized to conveniently load and format Gadget-derivative datasets such as GIZMO (ascl:1410.003). FIRE Studio is fast, memory efficient, and parallelizable. In addition to producing "1-color" projection maps for SPH datasets, the interface can produce "2-color" maps, where the pixel saturation is set by one projected quantity and the hue is set by another, and "3-color" maps, where three quantities are projected simultaneously and remapped into an RGB colorspace. FIRE Studio can model stellar emission and dust extinction to produce mock Hubble images (by default) or to model surface brightness maps for thirteen of the most common bands (plus the bolometric luminosity). It produces publication quality static images of simulation datasets and provides interpolation scripts to create movies that smoothly evolve in time (provided multiple snapshots in time of the data exist), view the dataset from different perspectives (taking advantage of shared memory buffers to allow massive parallelization), or both.

[ascl:2108.010] FIREFLY: Chi-squared minimization full spectral fitting code

FIREFLY (Fitting IteRativEly For Likelihood analYsis) derives stellar population properties of stellar systems, whether observed galaxy or star cluster spectra or model spectra from simulations. The code fits combinations of single-burst stellar population models to spectroscopic data following an iterative best-fitting process controlled by the Bayesian Information Criterion without applying priors. Solutions within a statistical cut are retained with their weight, which is arbitrary. No additive or multiplicative polynomia are used to adjust the spectral shape and no regularization is imposed. This fitting freedom allows mapping of the effect of intrinsic spectral energy distribution (SED) degeneracies, such as age, metallicity, dust reddening on stellar population properties, and quantifying the effect of varying input model components on such properties.

[ascl:1810.021] Firefly: Interactive exploration of particle-based data

Firefly provides interactive exploration of particle-based data in the browser. The user can filter, display vector fields, and toggle the visibility of their customizable datasets all on-the-fly. Different Firefly visualizations, complete with preconfigured data and camera view-settings, can be shared by URL. As Firefly is written in WebGL, it can be hosted online, though Firefly can also be used locally, without an internet connection. Firefly was developed with simulations of galaxy formation in mind but is flexible enough to display any particle-based data. Other features include a stereoscopic 3D picture mode and mobile compatibility.

[ascl:1908.023] FIRST Classifier: Automated compact and extended radio sources classifier

FIRST Classifier is an on-line system for automated classification of compact and extended radio sources. It is developed based on a trained Deep Convolutional Neural Network Model to automate the morphological classification of compact and extended radio sources observed in the FIRST radio survey. FIRST Classifier is able to predict the morphological class for a single source or for a list of sources as Compact or Extended (FRI, FRII and BENT).

[ascl:1202.014] FISA: Fast Integrated Spectra Analyzer

FISA (Fast Integrated Spectra Analyzer) permits fast and reasonably accurate age and reddening determinations for small angular diameter open clusters by using their integrated spectra in the (3600-7400) AA range and currently available template spectrum libraries. This algorithm and its implementation help to achieve astrophysical results in shorter times than from other methods. FISA has successfully been applied to integrated spectroscopy of open clusters, both in the Galaxy and in the Magellanic Clouds, to determine ages and reddenings.

[ascl:1010.070] Fisher.py: Fisher Matrix Manipulation and Confidence Contour Plotting

Fisher.py allows you to combine constraints from multiple experiments (e.g., weak lensing + supernovae) and add priors (e.g., a flat universe) simply and easily. Calculate parameter uncertainties and plot confidence ellipses. Fisher matrix expectations for several experiments are included as calculated by myself (time delays) and the Dark Energy Task Force (WL/SN/BAO/CL/CMB), or provide your own.

[ascl:1201.007] Fisher4Cast: Fisher Matrix Toolbox

The Fisher4Cast suite, which requires MatLab, provides a standard, tested tool set for general Fisher Information matrix prediction and forecasting for use in both research and education. The toolbox design is robust and modular, allowing for easy additions and adaptation while keeping the user interface intuitive and easy to use. Fisher4Cast is completely general but the default is coded for cosmology. It provides parameter error forecasts for cosmological surveys providing distance, Hubble expansion and growth measurements in a general, curved FLRW background.

[ascl:2308.015] FishLSS: Fisher forecasting for Large Scale Structure surveys

FishLSS computes the Fisher information matrix for a set of observables and model parameters. It can model the redshift-space power spectrum of any biased tracer of the CDM+baryon field and the post-reconstruction galaxy power spectrum. The code also models the projected cross-correlation of galaxies with the CMB lensing convergence, the projected galaxy power spectrum, and the CMB lensing convergence power spectrum. FishLSS requires pyFFTW (ascl:2109.009), velocileptors (ascl:2308.014), and CLASS (ascl:1106.020).

[ascl:1609.004] FISHPACK: Efficient FORTRAN Subprograms for the Solution of Separable Elliptic Partial Differential Equations

The FISHPACK collection of Fortran77 subroutines solves second- and fourth-order finite difference approximations to separable elliptic Partial Differential Equations (PDEs). These include Helmholtz equations in cartesian, polar, cylindrical, and spherical coordinates, as well as more general separable elliptic equations. The solvers use the cyclic reduction algorithm. When the problem is singular, a least-squares solution is computed. Singularities induced by the coordinate system are handled, including at the origin r=0 in cylindrical coordinates, and at the poles in spherical coordinates. A modernization of FISHPACK is available as FISHPACK90 (ascl:1609.005).

[ascl:1609.005] FISHPACK90: Efficient FORTRAN Subprograms for the Solution of Separable Elliptic Partial Differential Equations

FISHPACK90 is a modernization of the original FISHPACK (ascl:1609.004), employing Fortran90 to slightly simplify and standardize the interface to some of the routines. This collection of Fortran programs and subroutines solves second- and fourth-order finite difference approximations to separable elliptic Partial Differential Equations (PDEs). These include Helmholtz equations in cartesian, polar, cylindrical, and spherical coordinates, as well as more general separable elliptic equations. The solvers use the cyclic reduction algorithm. When the problem is singular, a least-squares solution is computed. Singularities induced by the coordinate system are handled, including at the origin r=0 in cylindrical coordinates, and at the poles in spherical coordinates. Test programs are provided for the 19 solvers. Each serves two purposes: as a template to guide you in writing your own codes utilizing the FISHPACK90 solvers, and as a demonstration on your computer that you can correctly produce FISHPACK90 executables.

Would you like to view a random code?