PatchMgr Class Reference

#include <PatchMgr.h>

Inheritance diagram for PatchMgr:

Public Member Functions
	PatchMgr ()
	~PatchMgr ()
void	createHomePatch (PatchID pid, FullAtomList &a)
void	movePatch (PatchID, NodeID)
void	sendMovePatches ()
void	recvMovePatches (MovePatchesMsg *msg)
void	sendAtoms (PatchID pid, FullAtomList &a)
void	recvAtoms (MovePatchesMsg *msg)
HomePatch *	homePatch (PatchID pid)
void	sendMigrationMsgs (PatchID, MigrationInfo *, int)
void	recvMigrateAtomsCombined (MigrateAtomsCombinedMsg *)
void	moveAtom (MoveAtomMsg *msg)
void	moveAllBy (MoveAllByMsg *msg)
void	setLattice (SetLatticeMsg *msg)
void	sendCheckpointReq (int pid, int remote, const char *key, int task)
void	recvCheckpointReq (CheckpointAtomsReqMsg *msg)
void	sendCheckpointLoad (CheckpointAtomsMsg *msg, int dst, int dstpe)
void	recvCheckpointLoad (CheckpointAtomsMsg *msg)
void	sendCheckpointStore (CheckpointAtomsMsg *msg, int dst, int dstpe)
void	recvCheckpointStore (CheckpointAtomsMsg *msg)
void	sendCheckpointAck (int pid, int dst, int dstpe)
void	recvCheckpointAck (CheckpointAtomsReqMsg *msg)
void	sendExchangeReq (int pid, int src)
void	recvExchangeReq (ExchangeAtomsReqMsg *msg)
void	sendExchangeMsg (ExchangeAtomsMsg *msg, int dst, int dstpe)
void	recvExchangeMsg (ExchangeAtomsMsg *msg)
void	setHomePatchFixedAtomNum (int patchId, int numFixed)
void	sendOneHomePatch (int patchId, int nodeId)

Static Public Member Functions
static PatchMgr *	Object ()

Friends
class	PatchMap

Detailed Description

Definition at line 145 of file PatchMgr.h.

Constructor & Destructor Documentation

PatchMgr()

PatchMgr::PatchMgr

(

)

Definition at line 34 of file PatchMgr.C.

References PatchMap::Instance(), NAMD_bug(), recvCheckpointAck_handler(), recvCheckpointLoad_handler(), recvCheckpointReq_handler(), recvCheckpointStore_handler(), recvExchangeMsg_handler(), recvExchangeReq_handler(), and PatchMap::registerPatchMgr().

{
    // CkPrintf("[%d] PatchMgr Created\n", CkMyPe());

    // Singleton pattern
    if (CkpvAccess(PatchMgr_instance) == NULL) {
        CkpvAccess(PatchMgr_instance) = this;
    } else {
        NAMD_bug("PatchMgr instanced twice on same processor!");
    }

    // Get PatchMap singleton started
    patchMap = PatchMap::Instance();
    patchMap->registerPatchMgr(this);

    recvCheckpointReq_index = CmiRegisterHandler((CmiHandler)recvCheckpointReq_handler);
    recvCheckpointLoad_index = CmiRegisterHandler((CmiHandler)recvCheckpointLoad_handler);
    recvCheckpointStore_index = CmiRegisterHandler((CmiHandler)recvCheckpointStore_handler);
    recvCheckpointAck_index = CmiRegisterHandler((CmiHandler)recvCheckpointAck_handler);

    recvExchangeReq_index = CmiRegisterHandler((CmiHandler)recvExchangeReq_handler);
    recvExchangeMsg_index = CmiRegisterHandler((CmiHandler)recvExchangeMsg_handler);

    // Message combining initialization
    migrationCountdown = 0;
    combineMigrationMsgs = new MigrateAtomsCombinedMsg*[CkNumPes()];
    int numPes = CkNumPes();
    for ( int i = 0; i < numPes; ++i ) combineMigrationMsgs[i] = 0;
}

~PatchMgr()

PatchMgr::~PatchMgr

(

)

Definition at line 64 of file PatchMgr.C.

References ResizeArrayIter< T >::begin(), ResizeArrayIter< T >::end(), SortedArray< Elem >::find(), and HomePatchElem::patch.

{
    HomePatchListIter hi(homePatches);
    for ( hi = hi.begin(); hi != hi.end(); hi++) {
      HomePatchElem* elem = homePatches.find(HomePatchElem(hi->pid));
      delete elem->patch;
    }
    delete [] combineMigrationMsgs;
}

Member Function Documentation

createHomePatch()

void PatchMgr::createHomePatch	(	PatchID	pid,
		FullAtomList &	a
	)

Definition at line 74 of file PatchMgr.C.

References SortedArray< Elem >::load(), and PatchMap::registerPatch().

Referenced by WorkDistrib::createHomePatches(), ParallelIOMgr::createHomePatches(), and recvMovePatches().

{
    HomePatch *patch = new HomePatch(pid, a);
    homePatches.load(HomePatchElem(pid, patch));
    patchMap->registerPatch(pid, patch);
}

homePatch()

HomePatch* PatchMgr::homePatch ( PatchID  pid )

inline

Definition at line 165 of file PatchMgr.h.

References SortedArray< Elem >::find(), and HomePatchElem::patch.

Referenced by sendMovePatches(), and sendOneHomePatch().

                                    {
     return homePatches.find(HomePatchElem(pid))->patch;
  } 

moveAllBy()

void PatchMgr::moveAllBy

(

MoveAllByMsg *

msg

)

Definition at line 246 of file PatchMgr.C.

References Lattice::apply_transform(), ResizeArray< Elem >::begin(), ResizeArray< Elem >::end(), FullAtom::fixedPosition, Patch::getNumAtoms(), Patch::lattice, MoveAllByMsg::offset, CompAtom::position, Lattice::reverse_transform(), and FullAtom::transform.

                                          {
  // loop over homePatches, moving every atom
  for (HomePatchElem *elem = homePatches.begin(); elem != homePatches.end(); elem++) {
    HomePatch *hp = elem->patch;
    for (int i=0; i<hp->getNumAtoms(); i++) {
      FullAtom &a = hp->atom[i];
      a.fixedPosition = hp->lattice.reverse_transform(a.position,a.transform);
      a.fixedPosition += msg->offset;
      a.position = hp->lattice.apply_transform(a.fixedPosition,a.transform);
    }
  }
  delete msg;
}

moveAtom()

void PatchMgr::moveAtom

(

MoveAtomMsg *

msg

)

Definition at line 228 of file PatchMgr.C.

References Lattice::apply_transform(), MoveAtomMsg::atomid, MoveAtomMsg::coord, FullAtom::fixedPosition, PatchMap::homePatch(), LocalID::index, Patch::lattice, AtomMap::localID(), MoveAtomMsg::moveto, notUsed, AtomMap::Object(), LocalID::pid, CompAtom::position, Lattice::reverse_transform(), and FullAtom::transform.

                                        {
  LocalID lid = AtomMap::Object()->localID(msg->atomid);
  if ( lid.pid != notUsed ) {
    HomePatch *hp = patchMap->homePatch(lid.pid);
    if ( hp ) {
      FullAtom &a = hp->atom[lid.index];
      if ( msg->moveto ) {
        a.fixedPosition = msg->coord;
      } else {
        a.fixedPosition = hp->lattice.reverse_transform(a.position,a.transform);
        a.fixedPosition += msg->coord;
      }
      a.position = hp->lattice.apply_transform(a.fixedPosition,a.transform);
    }
  }
  delete msg;
}

movePatch()

void PatchMgr::movePatch	(	PatchID	pid,
		NodeID	nodeID
	)

Definition at line 84 of file PatchMgr.C.

References SortedArray< Elem >::load().

Referenced by WorkDistrib::distributeHomePatches().

{
    move.load(MovePatch(pid,nodeID));
}

Object()

static PatchMgr* PatchMgr::Object ( )

inlinestatic

Definition at line 152 of file PatchMgr.h.

Referenced by HomePatch::doAtomMigration(), HomePatch::exchangeAtoms(), HomePatch::exchangeCheckpoint(), recvCheckpointAck_handler(), HomePatch::recvCheckpointLoad(), recvCheckpointLoad_handler(), HomePatch::recvCheckpointReq(), recvCheckpointReq_handler(), HomePatch::recvCheckpointStore(), recvCheckpointStore_handler(), recvExchangeMsg_handler(), HomePatch::recvExchangeReq(), and recvExchangeReq_handler().

{ return CkpvAccess(PatchMgr_instance); }

recvAtoms()

void PatchMgr::recvAtoms

(

MovePatchesMsg *

msg

)

Definition at line 168 of file PatchMgr.C.

References MovePatchesMsg::atom, PatchMap::homePatch(), and MovePatchesMsg::pid.

                                            {
    patchMap->homePatch(msg->pid)->reinitAtoms(msg->atom);
    delete msg;
}

recvCheckpointAck()

void PatchMgr::recvCheckpointAck

(

CheckpointAtomsReqMsg *

msg

)

Definition at line 380 of file PatchMgr.C.

References PatchMap::homePatch(), NAMD_bug(), CheckpointAtomsReqMsg::pid, and HomePatch::recvCheckpointAck().

Referenced by recvCheckpointAck_handler().

                                                           {
  HomePatch *hp = patchMap->homePatch(msg->pid);
  if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvCheckpointAck");
  hp->recvCheckpointAck();
  delete msg;
}

recvCheckpointLoad()

void PatchMgr::recvCheckpointLoad

(

CheckpointAtomsMsg *

msg

)

Definition at line 328 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsMsg::pid, and HomePatch::recvCheckpointLoad().

Referenced by recvCheckpointLoad_handler().

                                                         {
  HomePatch *hp = patchMap->homePatch(msg->pid);
  hp->recvCheckpointLoad(msg);
}

recvCheckpointReq()

void PatchMgr::recvCheckpointReq

(

CheckpointAtomsReqMsg *

msg

)

Definition at line 296 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsReqMsg::key, NAMD_bug(), PatchMap::node(), CheckpointAtomsReqMsg::pe, CheckpointAtomsReqMsg::pid, HomePatch::recvCheckpointReq(), CheckpointAtomsReqMsg::replica, and CheckpointAtomsReqMsg::task.

Referenced by recvCheckpointReq_handler().

                                                           {
  int patchnode = patchMap->node(msg->pid);
  if ( CkMyPe() != patchnode ) {
    thisProxy[patchnode].recvCheckpointReq(msg);
  } else {
    HomePatch *hp = patchMap->homePatch(msg->pid);
    if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvCheckpointReq");
    hp->recvCheckpointReq(msg->task, msg->key, msg->replica, msg->pe);
    delete msg;
  }
}

recvCheckpointStore()

void PatchMgr::recvCheckpointStore

(

CheckpointAtomsMsg *

msg

)

Definition at line 353 of file PatchMgr.C.

References PatchMap::homePatch(), CheckpointAtomsMsg::pid, and HomePatch::recvCheckpointStore().

Referenced by recvCheckpointStore_handler().

                                                          {
  HomePatch *hp = patchMap->homePatch(msg->pid);
  hp->recvCheckpointStore(msg);
}

recvExchangeMsg()

void PatchMgr::recvExchangeMsg

(

ExchangeAtomsMsg *

msg

)

Definition at line 435 of file PatchMgr.C.

References PatchMap::homePatch(), ExchangeAtomsMsg::pid, and HomePatch::recvExchangeMsg().

Referenced by recvExchangeMsg_handler().

                                                    {
  HomePatch *hp = patchMap->homePatch(msg->pid);
  hp->recvExchangeMsg(msg);
}

recvExchangeReq()

void PatchMgr::recvExchangeReq

(

ExchangeAtomsReqMsg *

msg

)

Definition at line 407 of file PatchMgr.C.

References ExchangeAtomsReqMsg::dstpe, PatchMap::homePatch(), NAMD_bug(), PatchMap::node(), ExchangeAtomsReqMsg::pid, and HomePatch::recvExchangeReq().

Referenced by recvExchangeReq_handler().

                                                       {
  int patchnode = patchMap->node(msg->pid);
  if ( CkMyPe() != patchnode ) {
    thisProxy[patchnode].recvExchangeReq(msg);
  } else {
    HomePatch *hp = patchMap->homePatch(msg->pid);
    if ( ! hp ) NAMD_bug("null HomePatch pointer in PatchMgr::recvExchangeReq");
    hp->recvExchangeReq(msg->dstpe);
    delete msg;
  }
}

recvMigrateAtomsCombined()

void PatchMgr::recvMigrateAtomsCombined

(

MigrateAtomsCombinedMsg *

msg

)

Definition at line 221 of file PatchMgr.C.

References DebugM, MigrateAtomsCombinedMsg::distribute(), ResizeArray< Elem >::size(), and MigrateAtomsCombinedMsg::srcPatchID.

{
  DebugM(3,"Received MigrateAtomsCombinedMsg with " << msg->srcPatchID.size() << " messages.\n");
  msg->distribute();
  delete msg;
}

recvMovePatches()

void PatchMgr::recvMovePatches

(

MovePatchesMsg *

msg

)

Definition at line 137 of file PatchMgr.C.

References MovePatchesMsg::atom, createHomePatch(), and MovePatchesMsg::pid.

                                                  {
    // Make a new HomePatch
    createHomePatch(msg->pid, msg->atom);
    delete msg;

    // Tell sending PatchMgr we received MovePatchMsg
//    AckMovePatchesMsg *ackmsg = 
//      new AckMovePatchesMsg;
//    CSendMsgBranch(PatchMgr,ackMovePatches, ackmsg, thisgroup, msg->fromNodeID);
}

sendAtoms()

void PatchMgr::sendAtoms	(	PatchID	pid,
		FullAtomList &	a
	)

Definition at line 157 of file PatchMgr.C.

References MovePatchesMsg::atom, NAMD_bug(), PatchMap::node(), and ResizeArray< Elem >::shared().

Referenced by WorkDistrib::reinitAtoms().

                                                     {

      MovePatchesMsg *msg = new MovePatchesMsg(pid, a);

      if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendAtoms");

      CProxy_PatchMgr cp(thisgroup);
      cp[patchMap->node(pid)].recvAtoms(msg);

}

sendCheckpointAck()

void PatchMgr::sendCheckpointAck	(	int	pid,
		int	dst,
		int	dstpe
	)

Definition at line 360 of file PatchMgr.C.

References CheckpointAtomsReqMsg::pid.

Referenced by HomePatch::recvCheckpointReq(), and HomePatch::recvCheckpointStore().

                                                            {
  CheckpointAtomsReqMsg *msg = new CheckpointAtomsReqMsg;
  msg->pid = pid;
  envelope *env = UsrToEnv(CheckpointAtomsReqMsg::pack(msg));
  CmiSetHandler(env,recvCheckpointAck_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
#endif
}

sendCheckpointLoad()

void PatchMgr::sendCheckpointLoad	(	CheckpointAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 310 of file PatchMgr.C.

Referenced by HomePatch::recvCheckpointReq().

                                                                             {
  envelope *env = UsrToEnv(CheckpointAtomsMsg::pack(msg));
  CmiSetHandler(env,recvCheckpointLoad_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
#endif
}

sendCheckpointReq()

void PatchMgr::sendCheckpointReq	(	int	pid,
		int	remote,
		const char *	key,
		int	task
	)

Definition at line 272 of file PatchMgr.C.

References CheckpointAtomsReqMsg::key, CheckpointAtomsReqMsg::pe, CheckpointAtomsReqMsg::pid, CheckpointAtomsReqMsg::replica, and CheckpointAtomsReqMsg::task.

Referenced by HomePatch::exchangeCheckpoint().

                                                                               {
  CheckpointAtomsReqMsg *msg = new (1+strlen(key),0) CheckpointAtomsReqMsg;
  msg->pid = pid;
  msg->pe = CkMyPe();
  msg->replica = CmiMyPartition();
  msg->task = task;
  strcpy(msg->key,key);
  envelope *env = UsrToEnv(CheckpointAtomsReqMsg::pack(msg));
  CmiSetHandler(env,recvCheckpointReq_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(CkMyPe(),remote,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
#endif
}

sendCheckpointStore()

void PatchMgr::sendCheckpointStore	(	CheckpointAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 335 of file PatchMgr.C.

Referenced by HomePatch::recvCheckpointLoad().

                                                                              {
  envelope *env = UsrToEnv(CheckpointAtomsMsg::pack(msg));
  CmiSetHandler(env,recvCheckpointStore_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
#endif
}

sendExchangeMsg()

void PatchMgr::sendExchangeMsg	(	ExchangeAtomsMsg *	msg,
		int	dst,
		int	dstpe
	)

Definition at line 419 of file PatchMgr.C.

Referenced by HomePatch::recvExchangeReq().

                                                                        {
  envelope *env = UsrToEnv(ExchangeAtomsMsg::pack(msg));
  CmiSetHandler(env,recvExchangeMsg_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(dstpe,dst,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(dstpe,env->getTotalsize(),(char*)env);
#endif
}

sendExchangeReq()

void PatchMgr::sendExchangeReq	(	int	pid,
		int	src
	)

Definition at line 388 of file PatchMgr.C.

References ExchangeAtomsReqMsg::dstpe, and ExchangeAtomsReqMsg::pid.

Referenced by HomePatch::exchangeAtoms().

                                               {
  ExchangeAtomsReqMsg *msg = new ExchangeAtomsReqMsg;
  msg->pid = pid;
  msg->dstpe = CkMyPe();
  envelope *env = UsrToEnv(ExchangeAtomsReqMsg::pack(msg));
  CmiSetHandler(env,recvExchangeReq_index);
#if CMK_HAS_PARTITION
  CmiInterSyncSendAndFree(CkMyPe(),src,env->getTotalsize(),(char*)env);
#else
  CmiSyncSendAndFree(CkMyPe(),env->getTotalsize(),(char*)env);
#endif
}

sendMigrationMsgs()

void PatchMgr::sendMigrationMsgs	(	PatchID	src,
		MigrationInfo *	m,
		int	numMsgs
	)

Definition at line 175 of file PatchMgr.C.

References MigrateAtomsCombinedMsg::add(), ResizeArray< Elem >::add(), DebugM, MigrationInfo::destNodeID, PatchMap::numHomePatches(), ResizeArray< Elem >::resize(), and ResizeArray< Elem >::size().

Referenced by HomePatch::doAtomMigration().

                                                                           {
/*
  for (int i=0; i < numMsgs; i++) {
    PatchMgr::Object()->sendMigrationMsg(src, m[i]);
  }
*/
  // The migration countdown is getting crapped up for some reason.
  // The migrationCountdown should be zero everytime I need to do a migration step here
  if ( ! migrationCountdown )  // (re)initialize
  {
    // DebugM(3,"migrationCountdown (re)initialize\n");
    numHomePatches = patchMap->numHomePatches();
    migrationCountdown = numHomePatches;
    combineMigrationDestPes.resize(0);
  }
  for (int i=0; i < numMsgs; i++) {  // buffer messages
    int destNodeID = m[i].destNodeID;
    if ( 1 ) // destNodeID != CkMyPe() )
    {
      if ( ! combineMigrationMsgs[destNodeID] )
      {
        combineMigrationMsgs[destNodeID] = new MigrateAtomsCombinedMsg();
        combineMigrationDestPes.add(destNodeID);
      }
      combineMigrationMsgs[destNodeID]->add(src,m[i].destPatchID,m[i].mList);
    }
    else
    {
        // for now buffer local messages too
    }
  }
  migrationCountdown -= 1;
  // DebugM(3,"migrationCountdown = " << migrationCountdown << "\n");
  if ( ! migrationCountdown )  // send out combined messages
  {
    int n = combineMigrationDestPes.size();
    for ( int i = 0; i < n; ++i ) {
        int destNodeID = combineMigrationDestPes[i];
        DebugM(3,"Sending MigrateAtomsCombinedMsg to node " << destNodeID << "\n");
        CProxy_PatchMgr cp(thisgroup);
        cp[destNodeID].recvMigrateAtomsCombined(combineMigrationMsgs[destNodeID]);
        combineMigrationMsgs[destNodeID] = 0;
    }
  }
}

sendMovePatches()

void PatchMgr::sendMovePatches

(

)

Definition at line 110 of file PatchMgr.C.

References MovePatchesMsg::atom, ResizeArrayIter< T >::begin(), SortedArray< Elem >::del(), ResizeArrayIter< T >::end(), homePatch(), NAMD_bug(), ResizeArray< Elem >::resize(), ResizeArray< Elem >::shared(), ResizeArray< Elem >::size(), and PatchMap::unregisterPatch().

Referenced by WorkDistrib::distributeHomePatches().

{
    if (! move.size())
        return;

    MovePatchListIter m(move);
    for ( m = m.begin(); m != m.end(); m++) {
      HomePatch *p = homePatch(m->pid);
      patchMap->unregisterPatch(m->pid, p);

      MovePatchesMsg *msg = new MovePatchesMsg(m->pid, p->atom);

      // Deleting the HomePatchElem will call a destructor for clean up
      // but the msg elements are safe since they use a container template
      // that uses ref counting.
      delete p;
      homePatches.del(HomePatchElem(m->pid)); 

      if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendMovePatches");

      // Sending to PatchMgr::recvMovePatches on remote node
      CProxy_PatchMgr cp(thisgroup);
      cp[m->nodeID].recvMovePatches(msg);
    }
    move.resize(0);
}

sendOneHomePatch()

void PatchMgr::sendOneHomePatch	(	int	patchId,
		int	nodeId
	)

Definition at line 89 of file PatchMgr.C.

References MovePatchesMsg::atom, SortedArray< Elem >::del(), homePatch(), NAMD_bug(), ResizeArray< Elem >::shared(), and PatchMap::unregisterPatch().

                                                      {
    HomePatch *p = homePatch(patchId);
    patchMap->unregisterPatch(patchId, p);

    MovePatchesMsg *msg = new MovePatchesMsg(patchId, p->atom);

    // Deleting the HomePatchElem will call a destructor for clean up
    // but the msg elements are safe since they use a container template
    // that uses ref counting.
    delete p;
    homePatches.del(HomePatchElem(patchId)); 

    if ( msg->atom.shared() ) NAMD_bug("shared message array in PatchMgr::sendOneHomePatch");

    // Sending to PatchMgr::recvMovePatches on remote node
    CProxy_PatchMgr cp(thisgroup);
    cp[nodeId].recvMovePatches(msg);
}

setHomePatchFixedAtomNum()

void PatchMgr::setHomePatchFixedAtomNum	(	int	patchId,
		int	numFixed
	)

Definition at line 440 of file PatchMgr.C.

References PatchMap::homePatch(), and Patch::setNumFixedAtoms().

                                                                {
    HomePatch *thisHomePatch = patchMap->homePatch(patchId);
    thisHomePatch->setNumFixedAtoms(numFixed);
}

setLattice()

void PatchMgr::setLattice

(

SetLatticeMsg *

msg

)

Definition at line 260 of file PatchMgr.C.

References ResizeArray< Elem >::begin(), ResizeArray< Elem >::end(), SetLatticeMsg::lattice, Patch::lattice, SimParameters::lattice, Node::Object(), and Node::simParameters.

                                            {
  // loop over homePatches, setting the lattice to the new value.
  for (HomePatchElem *elem = homePatches.begin(); elem != homePatches.end(); elem++) {
    HomePatch *hp = elem->patch;
    hp->lattice = msg->lattice;
  }
  // Must also do this for SimParameters in order for pressure profile to work!
  Node::Object()->simParameters->lattice = msg->lattice;
}

Friends And Related Function Documentation

PatchMap

friend class PatchMap

friend

Definition at line 193 of file PatchMgr.h.

---

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

• PatchMgr.h
• PatchMgr.C