SIMION 8.0 Issues/Bugs/Enhancements

Issue I503 [81,enhancement,partlyimplemented]
  Fast Parallel .PA# refines (one solution per CPU core)

  Normally, when SIMION refines a .PA# file, it refines each of the
  solution files (.PA0/.PA_, .PA1, .PA2, ...) in sequence.  However,
  one could increase the speed of this by refining these solutions
  separately, in parallel over multiple CPU cores.  This is possible
  only if you have more than one CPU core, such as a modern CPU with
  multiple CPU cores, a system with multiple CPUs, or even multiple
  computers.  In theory, you can cut your refine time down by a factor
  of 1/N where N is the number of adjustable electrodes, provided the
  individual solutions take about the same amount of time to refine,
  provided you have N cores, and provided there is little memory
  contention.

  In 8.1 early access mode (in 8.0.5-TEST22 or above), the "refine"
  function in the Lua simion.pas interface (Issue I422) has a new
  option in which you can specify that only a subset of the solution
  (0..N) should be refined in the current SIMION process.  So, to
  refine the solutions in parallel, you can start up multiple instances
  of SIMION and invoke the "refine" function with a disjoint subset
  of electrode solution numbers.

  For example, consider the quad1.pa# array (built from the quad1.gem
  file in "examples\performance_tests\7_dc_quadrupole_tests").  To
  build and refine only electrode solution #2 in the quad1.pa# array
  (i.e. quad1.pa2), you can run this Lua code:

    local pa = simion.pas:open('quad1.pa#')
    pa:refine{solutions={2}}

  The "solutions" option takes an array of electrode numbers, and here we
  only specified a single number.  Omitting this option will cause
  SIMION to generate all solutions in sequence.

  One can alternately invoke this from the command-line as follows as
  a Lua expression:

    simion.exe --nogui lua -e "local pa = simion.pas:open('quad1.pa#'); pa:refine{solutions={2}, convergence=1e-7}"

  In future SIMION updates, additional convenience methods for
  performing these actions will likely be provided.  In particular,
  there will likely be an option from the Refine screen (GUI) to run
  multiple threads.  For now, the only the most flexible Lua method is
  provided.

  So we could run the above code on three separate computers (or three
  separate CPU cores) while replacing the number 2 with 0, 1, or 2, to
  generate these three files in parallel.  Building the quad1.pa0 is
  virutally instantaneous, but the quad1.pa1 and quad1.pa2 files take
  some time to build, so it's really only useful to use two cores.  On
  a certain four core system tested (dual CPU, each with two cores),
  quad1.pa1 and quad2.pa2 take 13.3 seconds (6.5 seconds each) to
  refine in sequence but only 7.9 seconds to refine in parallel.

  As another example, icr.pa# takes 7.0 sec to refine sequentially to
  a 1e-7 convergence level (convergence=1e-7).  It takes 3.0 seconds
  when refined on three CPU cores on the same machine ({0,1,2}, {3,4},
  and {5,6}).

  If you are refining the solutions on multiple computers, it is
  recommended you set up a file share on one computer, place the .PA#
  file in that share and refine the three solutions for the .PA# file
  there.  Therefore, SIMION will place the solution files all in the
  same place.

  See the documentation on the simion.pas interface (Issue I422)
  for details on other parameters (e.g. convergence limit) that
  can be passed to the "refine" function.

  Implemented in 8.1 early access mode (8.0.5-TEST22).