Table of Contents

**newton0tree** [...same as in newton0...]
[**tol=**real] [**celldivision=**celldivisionmethod]

**newton0reg** [...same as in newton0...]
[**niter=**integer]

*newton0* is a simple type of gravitational
many-body code: simple in the sense of giving all particles equal time steps
at any given time (although the length of this shared time step does change
in time in an adaptive fashion; see below). Apart from this limitation the
code is rather flexible: it gives a choice of a number of integration schemes
which can be invoked on the command line; a choice of various softening
procedures; a choice of time step criterion; a choice of diagnostics provided
during the run; and it has a wide choice of start-up options, from a snapshot,
or a previously saved system state, or from scratch in which case newton0
produces a Plummer model.

*newton0tree* is an extension to *newton0* in which
a hierarchical force calculation is performed using an adaptive Eulerian
tree scheme (J. Barnes and P. Hut 1986, *Nature 324*, 446), which reduces the
number of pairwise force calculations per timestep from order #N sup 2#
to order #N log N# .

*newton0reg* is an extension to *newton0* in which a full
pairwise regularization scheme is implemented, based on the Kustaanheimo_Stiefel
four-dimensional regularization, as generalized by D.C. Heggie, *Celestial
Mechanics 10*, 217 (1974); and implemented following the recipes given by
S. Mikkola,

The code has
been written in a highly structured, modular and flexible way (see the
*Newton0 Primer*). It can thus serve as a blueprint for more advanced gravitational
many-body integration modules. Its generality makes it suitable for experimentation
with different integration, softening, timestep and diagnostics schemes.
When using *newton0* in production runs it may be advisable to throw out
some of the unneeded embellishments, and to optimize the inner loops -- but
remember: *premature optimization is the root of all evil* (or at least of
most).

**in=***infile*- If
*infile*is specified, a nbody snapshot is read in from this file (a quick way of preparing a simple system for testing purposes is to use*snapenter(1NEMO)*). The command line parameters are used to determine the type and duration of the integration, and the modes of output. Only one of the files*inputfile*,*restorefile*,*resumefile*may be specified: if none are specified, a new Plummer model is generated (Default: no file specification). **lastout=***lastoutfile*- If
*lastoutfile*is specified, then output data are written into this file in standard snapshot format at the end of the integration. Since only one output is performed, the integration can be viewed as a black box which maps an in-state to an out-state without any clutter of intermediate information. This option is useful for testing purposes, since the*lastoutfile*s of two different runs can be compared directly, for example using*snapdiff(1NEMO)*; using snapdiff on two*outfile*s would only compare the echos of the initial states, and later states would have to be extracted using*snaptrim(1NEMO)*before passing them to*snapdiff(1NEMO)*(Default: no file specification). **out=***outfile*- If
*outfile*is specified, then output data are written into this file in standard snapshot format, at time intervals regulated by*dt_min_out*and*dt_maj_out*(see below; Default: no file specification). **save=***savefile*- If
*savefile*is specified, the whole system state is saved periodically at time intervals*dt_save*. (Default: no file specification). **restore=***restorefile*- If
*restorefile*is specified, a previously saved system state is read in from this file. The command line parameters are ignored (in contrast to the following option below), and the system is run to completion solely according to the information contained in*restorefile*. Thus, unless*restorefile*contains an interrupted run, no integration will take place since*t_end*will already have been reached. Only one of the files*inputfile*,*restorefile*,*resumefile*may be specified: if none are specified, a new Plummer model is generated (Default: no file specification). **resume=***resumefile*- If
*resumefile*is specified, a previously saved system state is read in from this file. The command line parameters are used (in contrast to the previous option above) to determine the type and duration of the integration, and the modes of output. Only one of the files*inputfile*,*restorefile*,*resumefile*may be specified: if none are specified, a new Plummer model is generated (Default: no file specification). **restart=***restartfile*- If
*restartfile*is specified, newton0 will deposit into this file a command which will continue the present run after a systemcrash as if nothing had happened. Specifying a*restartfile*will be ignored if no*savefile*is specified as well. If both files are given, then the system is supposed to execute the*restartfile*automatically at reboot time (through some sort of specification in some sort of system file), and all will be well again, one hopes (Default: no file specification). **nbody=***integer*- number of particles in a newly generated Plummer model (Default:
*nbody*=3). **seed=***integer*- seed for the random number generator used in generating
a new Plummer model (default: a value 0, which will be converted into a
unique new value using UNIX’s clock time, in seconds since once-upon-a-time-in-the-seventies-of-the-previous-century).
See also
*xrandom(1NEMO)*for more info on seed= **t_begin=***real*- time at which
the integration starts (Default:
**t_begin=**0.0). **t_end=***real*- time at which the
integration will halt (Default:
**t_end=**1.0). **dt_minor=***real*- time intervals
between minor outputs, when diagnostics are printed on the standard output
channel and diagnostics are added to
*outfile*in snapshot format (Default:**dt_minor=**0.5). **dt_major=***real*- time intervals between major outputs, when diagnostics
are printed on the standard output channel and diagnostics as well as a
complete set of particle data are added to
*outfile*in snapshot format (Default:**dt_major=**1.0). **dt_save=***real*- time intervals between saving a complete system
state (Default:
**dt_save=**0.5). **dt_max=***real*- maximum length of the allowed
integration time step which is shared between all particles (Default:
**dt_max=**1000). **nstep=***integer*- maximum number of integration steps, after which execution
of the program is halted immediately (Default:
**nstep=**10000000). **min_pairdist=***real*- minimum allowed (softened) pair distance. If any pair of particles anywhere
in the system attains a (softened) separation smaller than
*min_pairdist*integration is halted. Note: when using softening, the pair distance measured is the softened distance between two particles. Specifying a minimum allowed pair distance smaller than the effective softening length therefore cannot halt integration (Default:**min_pairdist=**0.0). **de_max=***real*- maximum amount
of drift allowed in the total energy of the system. If the total energy
changes by more than this amount, integration is halted. The frequency with
which this test is applied is governed by the parameter
*nstep_de*as described below (Default:**de_max=**10000000). **nstep_de=***integer*- indicates the number
of time steps after which the total energy value is checked against
*de_macs*. (Default:**nstep_de=**10000000). **cpu_max=***real*- maximum amount of CPU time allowed
(expressed in minutes), after which execution of the program is halted
immediately (Default:
**cpu_max=**10000000). **cpu_last_call=***real*- soft limit on
the amount of CPU time used (expressed in minutes): after this amount has
been exceeded, execution of the program will be halted at the time of the
next major output. This allows a more graceful exit than the above hard
option of
*cpu_max*. Notice, however, that it may be prudent to give suitable limits for both these parameters, since an extreme condition such as a very close encounter may slow down simulated time to such an extent that the time of the next scheduled major output may "never" be reached (Default:**cpu_last_call=**10000000). **eta_acc=***real*- dimensionless integration accuracy
parameter, used in determining the size of the integration time step:
the step length is taken as the small fraction
*eta_acc*of the projected collision time. The latter is defined as follows: the relative distance and speed in each particle pair is determined, and from these the time scale of change defined as the ratio of the relative speed and the relative distance; the minimum of all these time scales is the projected collision time (Default:**eta_acc=**0.01). **r0_soft=***real*- softening length used to soften
the potential of a point mass according to the type of softening specified
by
*soft_focus*(see below; Default:**r0_soft=**0.0). **soft_focus=***softeningtype*- type of softening used to soften the potential of a point mass. The following
options are implemented:
*plummer*specifies the traditional softening in which each point particle assumes the potential of a density distribution according to a small Plummer model;*power4*is a generalization of the previous one in which the square of the softening length is replaced by the fourth power, giving a shorter range for the softening;*power8*is a similar generalization to the eight power;*exponential*is again similar, but has an exponentially short range;*sphere*replaces each point particle by a homogeneous sphere;*shell*replaces each point particle by a homogeneous shell;*spline*replaces each point particle by a cubic spline with compact support (Default:**soft_focus=**plummer). **timestep=***timestepcriterion*- criterion for determinening the next timestep.
Currently only two criteria are provided:
*constant*implies a constant time step equal to the value of*eta_acc*; and*collision_time*which adaptively determines the timestep as the fraction*eta_acc*of the timescale on which the first pair configuration changes significantly. Expressed more accurately: the relative distance and speed in each particle pair is determined, and from these the time scale of change which would be the time scale for a collision if position and velocity would be parallel and opposite; hence the name (Default:**timestep=**constant). **diagnostics=***diagnosticstype*- choice
of diagnostics output, in binary as well as in ascii. This will be a place
where a large variety of types of diagnostics can be offered in future
versions. Presently only one type is implemented (Default:
**diagnostics=**standard). **scheme=***integrationscheme*- integration scheme used to integration Newton’s
equations of motion for the whole system state (modeled as a set of 2*nbody*NDIM
simultaneous nonlinear ordinary differential equations). The following options
are implemented:
*forward_euler*,*backward_euler*,*runge_kutta_2*,*runge_kutta_4*,*runge_kutta_6*,*rk_fehlberg_45*. The first two are forward Euler and backwards Euler schemes, respectively; the next three are Runge-Kutta schemes of 2nd, 4th and 6th order, respectively; and the last one is a Runge-kutta-Fehlberg scheme of combined 4th and 5th order (the present implementation uses only the final, 5th order Runge-Kutta information of this last scheme) (Default:**scheme=**runge_kutta_4 for NEWTON0 and NEWTON0REG;**scheme=**leapfrog for NEWTON0TREE). **headline=***string*- Optional headline, which is written as the first item in the snapshot file, the next item being the snapshot itself (Default for NEWTON0: "Newton0code: equal time steps"; for NEWTON0REG: "Newton0 code: equal time steps & regularization"; for NEWTON0TREE: "Newton0 code: equal time steps & hierarchical tree forces").
**tol=***real*- ONLY for NEWTON0TREE: the
tolerance parameter, which determines which cells are subdivided: for example,
in the simplest
*celldivisonmethod*(see below), whenever the ratio of cell size over cell distance to a body is smaller than*tol*, the interaction between the cell and the body is computed directly without further subdivision (Default:**tol=**1.0). **celldivision=***celldivisonmethod*- ONLY for NEWTON0TREE:
the method used to decide when to subdivide a cell from which one wants
to compute the gravitational attraction on an individual particle. The simplest
method,
*constant_theta*, applies a constant opening-angle criterion (Default:**celldivision=**constant_theta). **niter=***integer*- ONLY for NEWTON0REG: number
of iterations performed in trying to arrive at the correct time to end
the integration (since integration is with respect to pseudo-time, the end
of an integration time step can only be predicted roughly with respect
to real time; iterating with increasing smaller timestep helps to zoom
in on the correct end-time; Default:
**niter=**3).

STARLAB: http://www.sns.ias.edu/~starlab/

The *Newton0
Primer* is lost...

NEMO/src/nbody/evolve/newton0source code

25-May-87Version 1.0: createdPIET 5-feb-01V2.0: converted for NEMO V3PJT 20-feb-042.0a: integrated in NEMO V3, fixed an I/O problemPJT