mdcore / News: Recent posts

New version featuring better scheduling with multiple tasks and work-stealing on multi-cores, pseudo-Verlet lists, and massively improved GPU performance.

P. Gonnet, A Short Note on the Fast Evaluation of Dihedral Angle Potentials and their Derivatives, Journal of Computational Physics, in Press, 231(7):2691-2694, http://dx.doi.org/10.1016/j.jcp.2011.12.022, 2012.

P. Gonnet, Pairwise Verlet lists: combining cell lists and Verlet lists to improve memory locality and parallelism, Journal of Computational Chemistry, 33(1):76-81, http://dx.doi.org/10.1002/jcc.21945, 2012.

A new version of mdcore has been uploaded. The most significant addition is support for CUDA-capable GPUs. To enable these features, use the configure flag "--with-cuda" and the flag "engine_flag_cuda" when calling "engine_init".

When CUDA is enabled, the number of threads passed to "engine_start" will be the number of blocks of 32 threads each to start on the GPU. The CUDA-capable engine also supports pairwise Verlet lists, which can be enabled with the "engine_flag_verlet_pairwise" flag.... read more

Added support for CUDA-capable GPUs, currently only in the SVN version.

A new version of mdcore has been uploaded which contains the latest improvements for non-bonded interactions and asynchronous MPI-based parallelism.

When using engine_step, which now handles the entire computation of bonded and non-bonded interactions, rigid constraints, communication and Verlet list updates, the timings of the individual computations can be accessed in the fields e.timers[], indexed by the engine_timer_* constants.

The timers are accumulative and can be reset with engine_timers_reset.

Note that the timers store "ticks" as defined in cycle.h. The conversion from "ticks" to seconds is platform-dependent!

A new flag engine_flag_async has been added for asynchronous communication. In this mode, engine_step calls engine_exchange_async which uses a spearate thread to handle communication.

The function engine_exchange_wait is used to wait for the communication to finalize.

In order to deal with this new feature, engine_rigid_sort has to be called before engine_rigid_eval.

In order to avoid non-bonded interactions between bonded pairs, exclusions can be added with engine_exclusion_add. Once all exclusions have been added, engine_exclusions_shrink is called to avoid duplicates.

To see how this is used in detail, see the "jac" and "apoa1" examples.

mdcore has been extended by the functions "engine_read_psf" and "engine_read_cpf" to read PSF and CHARMM parameter files respectively.

When reading the PSF, an atom type is created for every atom/charge combination and only those potentials in the CHARMM parameter file are generated which are actually needed.

Dihedral angle potentials can now be added with "engine_dihedral_add", much in the same way as angles and bonds are added.

The potentials are automatically evaluated by "engine_step".

The function "potential_create_harmonic_dihedral" has been added to automatically generate diheral potentials of the form "K(1+cos(ntheta+delta))".

The current SVN version now contains support for general holonomic constraints. To add a constraint, simply call

engine_rigid_add( e , pid , pjd , d );

where "e" is an initialized engine, "pid" and "pjd" are the ids of the two particles involved and "d" is their prescribed distance in nanometers.

The individual constraints are automatically grouped into rigid bodies which are then solved for using the SHAKE algorithm by calling ... read more

Some minor fixes and updates to the documentation.

Support for bonded and angular interactions has been added to the SVN version of the code.

The bond and angle potentials are evaluated using the same interpolated potentials as the non-bonded interactions. Since these potentials, in the angular case, are not necessarily functions of a squared radius, non-squared potential evaluators (e.g. removing the initial sqrt(r2)) have been added.

An example/flexible using flexible SPC water has been added.

Support for MPI-based parallelism has been added to the SVN version of the code.

The domain is decomposed using bisection and as such, only 2^k processors are efficiently supported. Ghost layers are used to map particles from other processors and particle data is exchanged only once per force evaluation, i.e. computations on ghost particles are duplicated. Communication scheduling is handled by not doing any explicit communication handling (e.g. graph coloring and the like) at all , but by using MPI's asynchronous communication primitives.... read more

Added a new source tarball for mdcore-0.1.2. The reason for this release is an upcoming paper (hopefully) for which the exact version used to compute the results should be publicly available.

As always, if you want to give mdcore a spin, it is still recommended to check-out the current SVN version (see http://mdcore.sourceforge.net/download.html).