144114 (2015).

Example input and data files can be found in

/examples/USER/cgdna/examples/duplex1/ and /duplex2/.

A simple python setup tool which creates single straight or helical DNA 

strands as well as DNA duplexes and arrays of duplexes can be found in 

/examples/USER/cgdna/util/.

A technical report with more information on the model, the structure 

of the input and data file, the setup tool and the performance of the 

LAMMPS-implementation of oxDNA can be found in

/doc/src/PDF/USER-CGDNA-overview.pdf.

/examples/USER/cgdna/examples/duplex1/ and /duplex2/.  A simple python

setup tool which creates single straight or helical DNA strands as

well as DNA duplexes and arrays of duplexes can be found in

/examples/USER/cgdna/util/.  A technical report with more information

on the model, the structure of the input and data file, the setup tool

and the performance of the LAMMPS-implementation of oxDNA can be found

in /doc/src/PDF/USER-CGDNA-overview.pdf.

IMPORTANT NOTE: This package can only be used if LAMMPS is compiled

with the MOLECULE and ASPHERE packages.  These should be included 

--------------------------------------------------------------------------

Bond styles provided by this package:

** Bond styles provided by this package:

bond_oxdna_fene.cpp:  backbone connectivity, a modified FENE potential

Pair styles provided by this package:

** Pair styles provided by this package:

pair_oxdna_excv.cpp:  excluded volume interaction between the nucleotides

pair_oxdna_coaxstk.cpp:  coaxial stacking interaction between nucleotides

Fixes provided by this package:

** Fixes provided by this package:

fix_nve_dotc_langevin.cpp:  fix for Langevin-type rigid body integrator "C"

                            in above Ref. [3] 

ComputeRDF::ComputeRDF(LAMMPS *lmp, int narg, char **arg) :

  Compute(lmp, narg, arg),

  rdfpair(NULL), nrdfpair(NULL), ilo(NULL), ihi(NULL), jlo(NULL), jhi(NULL),

  hist(NULL), histall(NULL), typecount(NULL), icount(NULL), jcount(NULL), duplicates(NULL)

  hist(NULL), histall(NULL), typecount(NULL), icount(NULL), jcount(NULL), 

  duplicates(NULL)

{

  if (narg < 4 || (narg-4) % 2) error->all(FLERR,"Illegal compute rdf command");

  }

  // (C) rule: 

  // for fix/compute requests, occasional or not does not matter

  // for fix/compute requests to be copied:

  // 1st check:

  // occasional or not does not matter

  // Kokkos host/device flags must match

  // SSA flag must match

  // newton setting must match (else list has different neighbors in it)

  // 2nd check:

  // if request = half and non-skip/copy pair half/respaouter request exists,

  // or if request = full and non-skip/copy pair full request exists,

  // or if request = gran and non-skip/copy pair gran request exists,

  // then morph to copy of the matching parent list

  // 2nd check: only if no match to 1st check

  // 3rd check: only if no match to 1st check

  // if request = half and non-skip/copy pair full request exists,

  // then morph to half_from_full of the matching parent list

  // for 1st or 2nd check, parent can be copy list or pair or fix

  int inewton,jnewton;

  for (i = 0; i < nrequest; i++) {

    if (!requests[i]->fix && !requests[i]->compute) continue;

    for (j = 0; j < nrequest; j++) {

      // Kokkos flags must match

      if (requests[i]->kokkos_device != requests[j]->kokkos_device) continue;

      if (requests[i]->kokkos_host != requests[j]->kokkos_host) continue;

      if (requests[i]->ssa != requests[j]->ssa) continue;

      // newton 2 and newton 0 both are newton off

      if ((requests[i]->newton & 2) != (requests[j]->newton & 2)) continue;

      // IJ newton = 1 for newton on, 2 for newton off

      inewton = requests[i]->newton;

      if (inewton == 0) inewton = force->newton_pair ? 1 : 2; 

      jnewton = requests[i]->newton;

      if (jnewton == 0) jnewton = force->newton_pair ? 1 : 2;

      if (inewton != jnewton) continue;

      if (requests[i]->half && requests[j]->pair && 

          !requests[j]->skip && requests[j]->half && !requests[j]->copy)

  }

  // reorder plist vector if necessary

  // relevant for lists that copy/skip/half-full from parent

  // relevant for lists that are derived from a parent list:

  //   half-full,copy,skip

  // the child index must appear in plist after the parent index

  // swap two indices within plist when dependency is mis-ordered

  // done when entire pass thru plist results in no swaps

  // start double loop check again whenever a swap is made

  // done when entire double loop test results in no swaps

  NeighList *ptr;

  while (!done) {

    done = 1;

    for (i = 0; i < npair_perpetual; i++) {

      for (k = 0; k < 3; k++) {

        ptr = NULL;

      if (lists[plist[i]]->listfull) ptr = lists[plist[i]]->listfull;

      if (lists[plist[i]]->listcopy) ptr = lists[plist[i]]->listcopy;

      // listskip check must be after listfull check

      if (lists[plist[i]]->listskip) ptr = lists[plist[i]]->listskip;

        if (k == 0) ptr = lists[plist[i]]->listcopy;

        if (k == 1) ptr = lists[plist[i]]->listskip;

        if (k == 2) ptr = lists[plist[i]]->listfull;

        if (ptr == NULL) continue;

        for (m = 0; m < nrequest; m++)

          if (ptr == lists[m]) break;

        done = 0;

        break;

      }

      if (!done) break;

    }

  }

  // debug output