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
Defines
#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)

---

Define 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 if(), NL_MSM_PERIODIC_VEC1, NL_MSM_PERIODIC_VEC2, NL_MSM_PERIODIC_VEC3, 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;
}

---