BwUniCluster2.0/Software/Mathematica
| Mathematica | ||
|---|---|---|
| module load | math/mathematica | |
| License | Commercial | |
| Citing | ||
| Links | Homepage; Documentation; | |
| Graphical Interface | Yes | |
| Included in module | ||
Mathematica is a software from Wolfram for symbolic and numerical computation with many features such as powerful visualization and application specific functions.
Loading
To check which versions of Mathematica are available execute
module avail math/mathematica
The default version can be loaded as usual with
module load math/mathematica
General Usage
Mathematica can be used interactively on the command line or with a graphical front-end. Alternatively Mathematica can run a script in batch mode which is useful when submitting batch jobs to the cluster. After loading Mathematica the different modes can be used as follows.
Interactive with command line:
./math
Interactive with GUI (needs X11 forwarding):
./mathematica
Non-Interatice:
./math < script.m
For an introduction to Mathematica we refer to the online documentation. Specific information on the use in a compute cluster is in the next section.
Parallel Computation
Obviously parallel computation can be useful to speed up a long running computation but it should also be used when multiple computations with different input data are needed (e.g. for parametric studies). The reason for this is the license model from Wolfram. There are two types of licenses. Each time an instance of Mathematica starts, a so called MathKernel license is used up. For each subprocesses Mathematica spawns, a license called SubMathKernel is used up. Because we have only a small number of MathKernel licenses it is necessary to start many subprocesses instead of submitting many jobs.
Remember to request the right amount of processors in your job script but note that Mathematica will not automatically use these processors. In general you have to change your code to benefit from more cores. To do this you first have to start a number of kernels which are then used by ParallelTable to run the computations in parallel. This basic example computes the first eight square numbers in parallel.
LaunchKernels[8]
f[i_] := i^2
DistributeDefinitions[f]
ParallelTable[f[i], {i,0,7}]
CloseKernels[]
Note that the use of DistributeDefinitions is necessary for f is a user defined function and the definition of this function must be available to all kernels.
The next example is the computation of the numerical solution of the following initial value problem
x'(t) = x^2(t) - x^3(t) x(0) = d
It is difficult to solve this equation with high accuracy at the point 1/d. We decrease the step size of the algorithm to see how the execution time and the relative error at the point 1/d change.
d = 0.00001
y[t_] := 1/(ProductLog[(1/d-1)*Exp[1/d-1-t]]+1) (* analytical solution *)
relerr[t_, s_] := Abs[(y[t] - x[t]/.s)/y[t]] (* relative error of solution s at time t*)
g[v_] := {v[[1]], v[[2]][[1]], relerr[1/d, v[[2]][[2]]][[1]]} (* helper function *)
(* compute numerical solutions for 6 different step sizes *)
LaunchKernels[6]
tbl = ParallelTable[{step, Timing[NDSolve[{x'[t] == x[t]^2 - x[t]^3, x[0] == d}, x, {t, 0, 2/d}, MaxStepSize->step, MaxSteps->10000000]]}, {step,5,3,-0.2}]
CloseKernels[]
Grid[Join[{{"Stepsize", "Time", "Error at 1/d"}}, Map[g, tbl]]] (* print the result *)
There are other functions similar to ParallelTable which are documented on the site http://reference.wolfram.com/mathematica/guide/ParallelComputing.html which provides general information on parallel computing with Mathematica.