ComputeMsmSerial.C File Reference

#include "InfoStream.h"
#include "Node.h"
#include "PatchMap.h"
#include "PatchMap.inl"
#include "AtomMap.h"
#include "ComputeMsmSerial.h"
#include "ComputeMsmSerialMgr.decl.h"
#include "PatchMgr.h"
#include "Molecule.h"
#include "ReductionMgr.h"
#include "ComputeMgr.h"
#include "ComputeMgr.decl.h"
#include "Debug.h"
#include "SimParameters.h"
#include "WorkDistrib.h"
#include "varsizemsg.h"
#include "msm.h"
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include "ComputeMsmSerialMgr.def.h"

Go to the source code of this file.

Classes
struct	ComputeMsmSerialAtom
class	MsmSerialCoordMsg
class	MsmSerialForceMsg
class	ComputeMsmSerialMgr

Macros
#define	MIN_DEBUG_LEVEL   3

Typedefs
typedef Force	MsmSerialForce

Functions
static void	rescale_nonperiodic_cell (Vector &u, Vector &v, Vector &w, Vector &c, Vector &ru, Vector &rv, Vector &rw, int isperiodic, int numatoms, const ComputeMsmSerialAtom *coord, double padding, double gridspacing)

Macro Definition Documentation

#define MIN_DEBUG_LEVEL   3

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Definition at line 20 of file ComputeMsmSerial.C.

Typedef Documentation

typedef Force MsmSerialForce

Definition at line 37 of file ComputeMsmSerial.C.

Function Documentation

static void rescale_nonperiodic_cell ( Vector &  u, Vector &  v, Vector &  w, Vector &  c, Vector &  ru, Vector &  rv, Vector &  rw, int  isperiodic, int  numatoms, const ComputeMsmSerialAtom *  coord, double  padding, double  gridspacing  )

static

Definition at line 170 of file ComputeMsmSerial.C.

References NL_MSM_PERIODIC_VEC1, NL_MSM_PERIODIC_VEC2, NL_MSM_PERIODIC_VEC3, numatoms, ComputeMsmSerialAtom::position, Vector::rlength(), Vector::x, Vector::y, and Vector::z.

Referenced by ComputeMsmSerialMgr::recvCoord().

                                        {
  const double NL_ZERO_TOLERANCE = 1e-4;
  double xlen = 1, inv_xlen = 1;  /* don't rescale periodic directions */
  double ylen = 1, inv_ylen = 1;
  double zlen = 1, inv_zlen = 1;
  double ulen_1 = u.rlength();
  double vlen_1 = v.rlength();
  double wlen_1 = w.rlength();
  double rpadx = padding * ulen_1;  /* padding distance in recip space */
  double rpady = padding * vlen_1;
  double rpadz = padding * wlen_1;
  double rhx = gridspacing * ulen_1;  /* grid spacing in recip space */
  double rhy = gridspacing * vlen_1;
  double rhz = gridspacing * wlen_1;
  Vector s, d;
  Vector rc = 0;  // don't move center along periodic directions
  double xmin, xmax, ymin, ymax, zmin, zmax;
  int is_periodic_x = (isperiodic & NL_MSM_PERIODIC_VEC1);
  int is_periodic_y = (isperiodic & NL_MSM_PERIODIC_VEC2);
  int is_periodic_z = (isperiodic & NL_MSM_PERIODIC_VEC3);
  int i;

  /* affine linear transformation of coordinates to reciprocal space,
   * where periodic vector directions map into [-0.5, 0.5) */
  //printf("*** center=%.4f %.4f %.4f\n", c.x, c.y, c.z);
  d = coord[0].position - c;
  s.x = ru * d;  // dot product
  s.y = rv * d;
  s.z = rw * d;
  xmin = xmax = s.x;
  ymin = ymax = s.y;
  zmin = zmax = s.z;
  for (i = 1;  i < numatoms;  i++) {
    d = coord[i].position - c;
    s.x = ru * d;  // dot product
    s.y = rv * d;
    s.z = rw * d;
    if      (s.x < xmin)  xmin = s.x;
    else if (s.x > xmax)  xmax = s.x;
    if      (s.y < ymin)  ymin = s.y;
    else if (s.y > ymax)  ymax = s.y;
    if      (s.z < zmin)  zmin = s.z;
    else if (s.z > zmax)  zmax = s.z;
  }
#if 0
  printf("*** xmin=%.4f  xmax=%.4f\n", xmin, xmax);
  printf("*** ymin=%.4f  ymax=%.4f\n", ymin, ymax);
  printf("*** zmin=%.4f  zmax=%.4f\n", zmin, zmax);
#endif

  if ( ! is_periodic_x) {
    xmax += rpadx;  /* pad the edges */
    xmin -= rpadx;
    if (rhx > 0) {  /* restrict center to rhx lattice points */
      double mupper = ceil(xmax / (2*rhx));
      double mlower = floor(xmin / (2*rhx));
      xmax = 2*rhx*mupper;
      xmin = 2*rhx*mlower;
    }
    rc.x = 0.5*(xmin + xmax);
    xlen = xmax - xmin;
    if (xlen < NL_ZERO_TOLERANCE) {
      xlen = 1;  /* leave scaling unchanged */
    }
    else {
      inv_xlen = 1/xlen;
    }
  }

  if ( ! is_periodic_y) {
    ymax += rpady;  /* pad the edges */
    ymin -= rpady;
    if (rhy > 0) {  /* restrict center to rhy lattice points */
      double mupper = ceil(ymax / (2*rhy));
      double mlower = floor(ymin / (2*rhy));
      ymax = 2*rhy*mupper;
      ymin = 2*rhy*mlower;
    }
    rc.y = 0.5*(ymin + ymax);
    ylen = ymax - ymin;
    if (ylen < NL_ZERO_TOLERANCE) {
      ylen = 1;  /* leave scaling unchanged */
    }
    else {
      inv_ylen = 1/ylen;
    }
  }

  if ( ! is_periodic_z) {
    zmax += rpadz;  /* pad the edges */
    zmin -= rpadz;
    if (rhz > 0) {  /* restrict center to rhz lattice points */
      double mupper = ceil(zmax / (2*rhz));
      double mlower = floor(zmin / (2*rhz));
      zmax = 2*rhz*mupper;
      zmin = 2*rhz*mlower;
    }
    rc.z = 0.5*(zmin + zmax);
    zlen = zmax - zmin;
    if (zlen < NL_ZERO_TOLERANCE) {
      zlen = 1;  /* leave scaling unchanged */
    }
    else {
      inv_zlen = 1/zlen;
    }
  }

#if 0
  printf("xmin=%g  xmax=%g\n", xmin, xmax);
  printf("ymin=%g  ymax=%g\n", ymin, ymax);
  printf("zmin=%g  zmax=%g\n", zmin, zmax);
  printf("xlen=%g  ylen=%g  zlen=%g\n", xlen, ylen, zlen);
  printf("rc_x=%g  rc_y=%g  rc_z=%g\n", rc.x, rc.y, rc.z);
#endif

  /* transform new center back to real space, then rescale basis vectors */
  c.x = (u.x*rc.x + v.x*rc.y + w.x*rc.z) + c.x;
  c.y = (u.y*rc.x + v.y*rc.y + w.y*rc.z) + c.y;
  c.z = (u.z*rc.x + v.z*rc.y + w.z*rc.z) + c.z;

#if 0
  printf("c_x=%g  c_y=%g  c_z=%g\n", c.x, c.y, c.z);
#endif

  u *= xlen;
  v *= ylen;
  w *= zlen;

  ru *= inv_xlen;
  rv *= inv_ylen;
  rw *= inv_zlen;
}