ComputeEwald Class Reference

#include <ComputeEwald.h>

Inheritance diagram for ComputeEwald:

Public Member Functions
	ComputeEwald (ComputeID, ComputeMgr *)
virtual	~ComputeEwald ()
void	doWork ()
void	recvData (ComputeEwaldMsg *)
void	recvResults (ComputeEwaldMsg *)
int	getMasterNode () const
Public Member Functions inherited from ComputeHomePatches
	ComputeHomePatches (ComputeID c)
virtual	~ComputeHomePatches ()
virtual void	initialize ()
virtual void	atomUpdate ()
Flags *	getFlags (void)
Public Member Functions inherited from Compute
	Compute (ComputeID)
int	type ()
virtual	~Compute ()
void	setNumPatches (int n)
int	getNumPatches ()
virtual void	patchReady (PatchID, int doneMigration, int seq)
virtual int	noWork ()
virtual void	finishPatch (int)
int	sequence (void)
int	priority (void)
int	getGBISPhase (void)
virtual void	gbisP2PatchReady (PatchID, int seq)
virtual void	gbisP3PatchReady (PatchID, int seq)

Additional Inherited Members
Public Attributes inherited from Compute
const ComputeID	cid
LDObjHandle	ldObjHandle
LocalWorkMsg *const	localWorkMsg
Protected Member Functions inherited from Compute
void	enqueueWork ()
Protected Attributes inherited from ComputeHomePatches
int	useAvgPositions
int	hasPatchZero
ComputeHomePatchList	patchList
PatchMap *	patchMap
Protected Attributes inherited from Compute
int	computeType
int	basePriority
int	gbisPhase
int	gbisPhasePriority [3]

Detailed Description

Definition at line 78 of file ComputeEwald.h.

Constructor & Destructor Documentation

ComputeEwald()

ComputeEwald::ComputeEwald	(	ComputeID	c,
		ComputeMgr *	m
	)

Definition at line 51 of file ComputeEwald.C.

References DebugM, ComputeNonbondedUtil::ewaldcof, generateAtomTypeTable(), PatchMap::Object(), Node::Object(), ReductionMgr::Object(), SimParameters::pressureProfileAtomTypes, SimParameters::pressureProfileEwaldX, SimParameters::pressureProfileEwaldY, SimParameters::pressureProfileEwaldZ, SimParameters::pressureProfileSlabs, REDUCTIONS_PPROF_NONBONDED, Node::simParameters, and ReductionMgr::willSubmit().

        : ComputeHomePatches(c)
{
  DebugM(3,"Constructing client\n");
  comm = m;
  SimParameters *sp = Node::Object()->simParameters;
  kxmax = sp->pressureProfileEwaldX;
  kymax = sp->pressureProfileEwaldY;
  kzmax = sp->pressureProfileEwaldZ;
  
  ktot = (1+kxmax) * (2*kymax+1) * (2*kzmax+1);
  kappa = ComputeNonbondedUtil::ewaldcof;
  pressureProfileSlabs = sp->pressureProfileSlabs;
  numAtomTypes = sp->pressureProfileAtomTypes;
  int nelements = 3*pressureProfileSlabs * (numAtomTypes*(numAtomTypes+1))/2;
  pressureProfileData = new float[nelements];
  reduction = ReductionMgr::Object()->willSubmit(
                                REDUCTIONS_PPROF_NONBONDED, nelements);

  // figure out who da masta be
  numWorkingPes = (PatchMap::Object())->numNodesWithPatches();
  masterNode = numWorkingPes - 1;

  recvCount = 0;
  localAtoms = NULL;
  localPartitions = NULL;

  expx = new float[kxmax+1];
  expy = new float[kymax+1];
  expz = new float[kzmax+1];

  if (CkMyPe() == masterNode) {
    eiktotal = new float[2 * ktot * numAtomTypes]; 
    memset(eiktotal, 0, 2 * ktot * numAtomTypes*sizeof(float));
  } else {
    eiktotal = NULL;
  }
  // space for exp(iky), k=-kymax, ..., kymax
  eiky = new floatcomplex[2*kymax+1];
  // space for exp(ikz), k=-kzmax, ..., kzmax
  eikz = new floatcomplex[2*kzmax+1];
  Qk = new float[3*ktot];

  gridsForAtomType = generateAtomTypeTable(numAtomTypes);
}

~ComputeEwald()

ComputeEwald::~ComputeEwald ( )

virtual

Definition at line 97 of file ComputeEwald.C.

{
  delete reduction;
  delete [] expx;
  delete [] expy;
  delete [] expz;
  delete [] eiktotal;
  delete [] eiky;
  delete [] eikz;
  delete [] pressureProfileData;
  delete [] Qk;
  delete [] gridsForAtomType;
  
  if (localAtoms) free(localAtoms);
  if (localPartitions) free(localPartitions);
}

Member Function Documentation

doWork()

void ComputeEwald::doWork ( void  )

virtual

Reimplemented from Compute.

Definition at line 114 of file ComputeEwald.C.

References ResizeArrayIter< T >::begin(), Lattice::c(), EwaldParticle::cg, CompAtom::charge, COULOMB, ComputeNonbondedUtil::dielectric_1, ComputeEwaldMsg::eik, ResizeArrayIter< T >::end(), Lattice::origin(), CompAtom::partition, ComputeHomePatches::patchList, CompAtom::position, ComputeNonbondedUtil::scaling, ComputeMgr::sendComputeEwaldData(), SubmitReduction::submit(), Lattice::wrap_delta(), EwaldParticle::x, Vector::x, EwaldParticle::y, Vector::y, EwaldParticle::z, and Vector::z.

                          {
  ResizeArrayIter<PatchElem> ap(patchList);
  // Skip computations if nothing to do.
  if ( ! patchList[0].p->flags.doFullElectrostatics )
  {
    for (ap = ap.begin(); ap != ap.end(); ap++) {
      CompAtom *x = (*ap).positionBox->open();
      Results *r = (*ap).forceBox->open();
      (*ap).positionBox->close(&x);
      (*ap).forceBox->close(&r);
    }
    reduction->submit();
    return;
  }


  lattice = patchList[0].p->lattice;
  Vector o = lattice.origin();

  // recompute pressure profile cell parameters based on current lattice
  pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
  pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;

  const BigReal coulomb_sqrt = sqrt( COULOMB * ComputeNonbondedUtil::scaling
                                * ComputeNonbondedUtil::dielectric_1 );

  // get coordinates and store them
  numLocalAtoms = 0;
  for (ap = ap.begin(); ap != ap.end(); ap++) {
    numLocalAtoms += (*ap).p->getNumAtoms();
  }
  localAtoms = (EwaldParticle *)realloc(localAtoms, numLocalAtoms*sizeof(EwaldParticle));
  localPartitions = (int *)realloc(localPartitions, numLocalAtoms*sizeof(int));

  EwaldParticle *data_ptr = localAtoms;
  int *part_ptr = localPartitions;

  for (ap = ap.begin(); ap != ap.end(); ap++) {
    CompAtom *x = (*ap).positionBox->open();
    // CompAtomExt *xExt = (*ap).p->getCompAtomExtInfo();
    Results *r = (*ap).forceBox->open();
    if ( patchList[0].p->flags.doMolly ) {
      (*ap).positionBox->close(&x);
      x = (*ap).avgPositionBox->open();
    }
    int numAtoms = (*ap).p->getNumAtoms();

    for(int i=0; i<numAtoms; ++i) {
      // wrap back to unit cell, centered on origin
      Vector pos = x[i].position;
      pos += lattice.wrap_delta(pos) - o;
      *part_ptr++ = x[i].partition; 
      data_ptr->x = pos.x;
      data_ptr->y = pos.y;
      data_ptr->z = pos.z;
      data_ptr->cg = coulomb_sqrt * x[i].charge;
      ++data_ptr;
    }
    (*ap).positionBox->close(&x);
    (*ap).forceBox->close(&r);
  }

  // compute structure factor contribution from local atoms
  // 2*ktot since charm++ uses float instead of floatcomplex
  int msgsize = 2 * numAtomTypes * ktot;
  ComputeEwaldMsg *msg = new (msgsize,0) ComputeEwaldMsg;
  memset(msg->eik, 0, msgsize*sizeof(float));
  compute_structurefactor(msg->eik);

  // send our partial sum
  comm->sendComputeEwaldData(msg);
}

getMasterNode()

int ComputeEwald::getMasterNode ( ) const

inline

Definition at line 86 of file ComputeEwald.h.

Referenced by ComputeMgr::sendComputeEwaldData().

{ return masterNode; }

recvData()

void ComputeEwald::recvData

(

ComputeEwaldMsg *

msg

)

Definition at line 187 of file ComputeEwald.C.

References ComputeEwaldMsg::eik, and ComputeMgr::sendComputeEwaldResults().

Referenced by ComputeMgr::recvComputeEwaldData().

                                                {
  // sum the data...
  int nvecs = 2 * ktot * numAtomTypes;
  for (int i=0; i<nvecs; i++) {
    eiktotal[i] += msg->eik[i];
  }
  delete msg;
  if (++recvCount == numWorkingPes) {
    recvCount = 0;
    int msgsize = 2 * ktot * numAtomTypes;
    msg = new (msgsize,0) ComputeEwaldMsg; 
    memcpy(msg->eik, eiktotal, msgsize*sizeof(float));
    memset(eiktotal, 0, msgsize*sizeof(float));
    comm->sendComputeEwaldResults(msg);
  }
}

recvResults()

void ComputeEwald::recvResults

(

ComputeEwaldMsg *

msg

)

Definition at line 204 of file ComputeEwald.C.

References ComputeEwaldMsg::eik, SubmitReduction::item(), M_PI, SubmitReduction::submit(), and Lattice::volume().

Referenced by ComputeMgr::recvComputeEwaldResults().

                                                   {
  // receive total sum
  computePprofile(msg->eik);
  delete msg;
  float scalefac = 1.0 / (2 * M_PI * lattice.volume());

  int nelements = 3*pressureProfileSlabs * (numAtomTypes*(numAtomTypes+1))/2;
  for (int i=0; i<nelements; i++) {
    reduction->item(i) += pressureProfileData[i] * scalefac;
  }
  reduction->submit();
}

---

The documentation for this class was generated from the following files:

• ComputeEwald.h
• ComputeEwald.C