Circuitscape is an open-source program that uses circuit theory to model connectivity in heterogeneous landscapes. Its most common applications include modeling movement and gene flow of plants and animals, as well as identifying areas important for connectivity conservation.
Circuitscape has now been rewritten in Julia for better performance and scalability. Julia is modern open-source language for scientific computing.
This work is based on the original Circuitscape project by Brad McRae, Viral B. Shah and Tanmay Mohapatra.
The New Circuitscape - Modern, Fast and Flexible
The new Circuitscape is built entirely in the Julia language, a new programming language for technical computing. Julia is built from the ground up to be fast. As such, this offers a number of advantages over the previous version, and these are detailed below.
Faster and More Scalable
Circuitscape.jl (v0.1.0) with the Python version (v4.0.5) to obtain the
following results. We started up Circuitscape with 16 parallel processes,
and used benchmark problems from the standard Circuitscape
These benchmarks were run on a Linux (Ubuntu) server machine with the following specs:
- Name: Intel(R) Xeon(R) Silver 4114 CPU
- Clock Speed: 2.20GHz
- Number of cores: 20
- RAM: 384 GB
From the benchmark, we see that the new version is upto 4x faster on 16 processes. However, the best performing bar in the chart is Julia-CHOLMOD, which is a new feature introduced.
New Solver Mode - CHOLMOD
Julia-CHOLMOD is a new solver mode used in the new Circuitscape. It performs a cholesky decomposition on the graph constructed, and performs a batched back substitution to compute the voltages. It plugs into the CHOLMOD library, which is part of the SuiteSparse collection of high performance sparse matrix algorithms.
To use the this new mode, include a line in your Circuitscape INI file:
solver = cholmod
The cholesky decomposition is a direct solver method, unlike the algebraic multigrid method used by default in both the old and the new version. The advantage with this new direct method is that it can be much faster than the iterative solution, within a particular problem size.
Word of caution: The cholesky decomposition is not practical to use beyond a certain problem size because of phenomenon called fill-in, which results in loss of sparsity and large memory consumption.
The old Circuitscape had limited support for parallelism, which worked on Mac and Linux, but didn't work on Windows.
Julia as a programming language is built from the ground up to be parallel, and as a result the new Circuitscape natively supports parallelism on all three platforms.
Single Precision (Experimental)
The new Circuitscape introduces the ability to run problems in single precision as opposed to the standard double precision.
Single precision usually takes much less memory, but trades off against solution accuracy.
Use this new feature by including a line in your config file:
precision = single
You will need to install Julia on your system first.
Once you start Julia, install Circuitscape by:
If you want the latest development version, you can additionally do:
Check if all the tests are passing by doing the following:
The current interface to Circuitscape is through the Julia terminal.
julia> using Circuitscape # loads the package into your environment julia> compute("path/to/config/file.ini")