GlobalMasterIMD Class Reference

#include <GlobalMasterIMD.h>

Inheritance diagram for GlobalMasterIMD:

Public Member Functions
	GlobalMasterIMD ()
	~GlobalMasterIMD ()
void	send_energies (IMDEnergies *)
void	send_fcoords (int, FloatVector *)
void	send_velocities (int, FloatVector *)
void	send_forces (int, FloatVector *)
void	send_box (IMDBox *)
void	send_time (IMDTime *)
Public Member Functions inherited from GlobalMaster
void	processData (AtomIDList::iterator a_i, AtomIDList::iterator a_e, PositionList::iterator p_i, PositionList::iterator g_i, PositionList::iterator g_e, BigRealList::iterator gm_i, BigRealList::iterator gm_e, ForceList::iterator gtf_i, ForceList::iterator gtf_e, IntList::iterator goi_i, IntList::iterator goi_e, BigRealList::iterator gov_i, BigRealList::iterator gov_e, AtomIDList::iterator last_atoms_forced_i, AtomIDList::iterator last_atoms_forced_e, ForceList::iterator last_forces_i, AtomIDList::iterator, AtomIDList::iterator, ForceList::iterator)
bool	changedAtoms ()
const AtomIDList &	requestedAtoms ()
bool	changedForces ()
const AtomIDList &	forcedAtoms ()
const ForceList &	appliedForces ()
bool	changedGroups ()
const ResizeArray< AtomIDList > &	requestedGroups ()
const ForceList &	groupForces ()
bool	changedGridObjs ()
const IntList &	requestedGridObjs ()
const BigRealList &	gridObjForces ()
bool	requestedTotalForces ()
void	clearChanged ()
virtual	~GlobalMaster ()
void	check () const
void	setLattice (const Lattice *lat)

Protected Member Functions
virtual void	calculate ()
void	imd_connection ()
void	get_vmd_forces ()
Protected Member Functions inherited from GlobalMaster
	GlobalMaster ()
AtomIDList &	modifyRequestedAtoms ()
AtomIDList &	modifyForcedAtoms ()
ForceList &	modifyAppliedForces ()
ResizeArray< AtomIDList > &	modifyRequestedGroups ()
ForceList &	modifyGroupForces ()
IntList &	modifyRequestedGridObjects ()
BigRealList &	modifyGridObjForces ()
AtomIDList::const_iterator	getAtomIdBegin ()
AtomIDList::const_iterator	getAtomIdEnd ()
PositionList::const_iterator	getAtomPositionBegin ()
PositionList::const_iterator	getGroupPositionBegin ()
PositionList::const_iterator	getGroupPositionEnd ()
ForceList::const_iterator	getGroupTotalForceBegin ()
ForceList::const_iterator	getGroupTotalForceEnd ()
IntList::const_iterator	getGridObjIndexBegin ()
IntList::const_iterator	getGridObjIndexEnd ()
BigRealList::const_iterator	getGridObjValueBegin ()
BigRealList::const_iterator	getGridObjValueEnd ()
AtomIDList::const_iterator	getLastAtomsForcedBegin ()
AtomIDList::const_iterator	getLastAtomsForcedEnd ()
ForceList::const_iterator	getLastForcesBegin ()
AtomIDList::const_iterator	getForceIdBegin ()
AtomIDList::const_iterator	getForceIdEnd ()
ForceList::const_iterator	getTotalForce ()
void	requestTotalForce (bool yesno=true)
BigRealList::const_iterator	getGroupMassBegin ()
BigRealList::const_iterator	getGroupMassEnd ()
void	addReductionEnergy (int reductionTag, BigReal energy)
SubmitReduction *	getCurrentReduction ()
void	submitReduction ()

Protected Attributes
int	IMDversion
int	IMDwait
int	IMDignore
int	IMDignoreForces
IMDSessionInfo	IMDsendsettings
void *	sock
ResizeArray< void * >	clients
float *	coordtmp
int	coordtmpsize
float *	veltmp
int	veltmpsize
float *	forcetmp
int	forcetmpsize
int	IMDv3TimeoutSeconds
Protected Attributes inherited from GlobalMaster
bool	totalForceRequested
const Lattice *	lattice
AtomIDList::iterator	atomIdBegin
AtomIDList::iterator	atomIdEnd
PositionList::iterator	atomPositionBegin
PositionList::iterator	groupPositionBegin
PositionList::iterator	groupPositionEnd
BigRealList::iterator	groupMassBegin
BigRealList::iterator	groupMassEnd
ForceList::iterator	groupTotalForceBegin
ForceList::iterator	groupTotalForceEnd
IntList::iterator	gridObjIndexBegin
IntList::iterator	gridObjIndexEnd
BigRealList::iterator	gridObjValueBegin
BigRealList::iterator	gridObjValueEnd
AtomIDList::iterator	lastAtomsForcedBegin
ForceList::iterator	lastForcesBegin
AtomIDList::iterator	lastAtomsForcedEnd
AtomIDList::iterator	forceIdBegin
AtomIDList::iterator	forceIdEnd
ForceList::iterator	totalForceBegin
bool	reqAtomsChanged
AtomIDList	reqAtoms
bool	appForcesChanged
AtomIDList	fAtoms
ForceList	appForces
bool	reqGroupsChanged
ResizeArray< AtomIDList >	reqGroups
ForceList	grpForces
bool	reqGridObjsChanged
IntList	reqGridObjs
BigRealList	gridobjForces
SubmitReduction *	reductionGpuResident
SubmitReduction *	reduction

Friends
class	IMDOutput

Additional Inherited Members
Public Attributes inherited from GlobalMaster
int	step
int	globalMasterStep
int	old_num_groups_requested

Detailed Description

Definition at line 17 of file GlobalMasterIMD.h.

Constructor & Destructor Documentation

GlobalMasterIMD()

GlobalMasterIMD::GlobalMasterIMD

(

)

Note

In case of (IMDignore || IMDignoreForces), the GlobalMasterIMD object is not a client of GlobalMasterServer, and GlobalMasterIMD->calculate() will be only called from IMDOutput::gather_*, and the subsequent GlobalMaster::submitReduction() won't be called. Moreover, GlobalMasterIMD->calculate() is called in a multiple time stepping manner, so GlobalMaster::submitReduction() cannot be used in GlobalMasterIMD->calculate() in case of (IMDignore || IMDignoreForces). To workaround the issue, we have to delete the reduction object, which should be safe since GlobalMasterIMD doesn't use GlobalMaster::addReductionEnergy().

Definition at line 56 of file GlobalMasterIMD.C.

References coordtmp, coordtmpsize, DebugM, endi(), find_free_port(), forcetmp, forcetmpsize, iINFO(), Node::imd, IMDignore, SimParameters::IMDignore, IMDignoreForces, SimParameters::IMDignoreForces, SimParameters::IMDport, IMDsendsettings, SimParameters::IMDsendsettings, IMDv3TimeoutSeconds, IMDversion, SimParameters::IMDversion, IMDwait, SimParameters::IMDwait, iout, iWARN(), NAMD_die(), Node::Object(), GlobalMaster::reduction, GlobalMaster::reductionGpuResident, GlobalMaster::requestedGroups(), Node::simParameters, sock, IMDOutput::use_imd(), veltmp, veltmpsize, vmdsock_create(), vmdsock_destroy(), vmdsock_init(), and vmdsock_listen().

                                 {
  DebugM(3,"Constructing\n");
  SimParameters *simparams = Node::Object()->simParameters;
  int port = simparams->IMDport;
  IMDversion = simparams->IMDversion;
  IMDwait = simparams->IMDwait;
  IMDignore = simparams->IMDignore;
  IMDignoreForces = simparams->IMDignoreForces;
  IMDsendsettings = simparams->IMDsendsettings;
  coordtmp = NULL;
  coordtmpsize = 0;
  veltmp = NULL;
  veltmpsize = 0;
  forcetmp = NULL;
  forcetmpsize = 0;

  if ( vmdsock_init() ) {
    NAMD_die("Unable to initialize socket interface for IMD.\n");
  }
  sock = vmdsock_create();
  int newport = find_free_port(sock, port);
  if (newport != port) {
    iout << iWARN << "Interactive MD failed to bind to port "
                  << port << ".\n" << endi;
  }
  if (newport < 0) {
    vmdsock_destroy(sock);
    NAMD_die("Interactive MD failed to find free port.\n");
  }
  vmdsock_listen(sock); 
  iout << iINFO << "Interactive MD listening on port "
                  << newport << ".\n" << endi;
  DebugM(2,"Done constructing ("<<requestedGroups().size()<<" initial groups)\n");

  if (IMDignore || IMDignoreForces) {
    if (reduction) {
      delete reduction;
      reduction = nullptr;
    }
#if (defined (NAMD_CUDA) || defined (NAMD_HIP))
    if (reductionGpuResident) {
      delete reductionGpuResident;
      reductionGpuResident = nullptr;
    }
#endif
  }
  Node::Object()->imd->use_imd(this);

  IMDv3TimeoutSeconds = 60;
}

~GlobalMasterIMD()

GlobalMasterIMD::~GlobalMasterIMD

(

)

Definition at line 118 of file GlobalMasterIMD.C.

References clients, coordtmp, forcetmp, ResizeArray< Elem >::size(), sock, veltmp, and vmdsock_destroy().

                                  {
  if (sock) 
    vmdsock_destroy(sock);
  for (int i=0; i<clients.size(); i++)
    vmdsock_destroy(clients[i]);
  if (coordtmp) delete [] coordtmp;
  if (veltmp) delete[] veltmp;
  if (forcetmp) delete[] forcetmp;
}

Member Function Documentation

calculate()

void GlobalMasterIMD::calculate ( )

protectedvirtual

Reimplemented from GlobalMaster.

Definition at line 179 of file GlobalMasterIMD.C.

References clients, DebugM, vmdforce::force, get_vmd_forces(), imd_connection(), IMDignore, IMDignoreForces, IMDv2, IMDversion, IMDwait, vmdforce::index, ResizeArray< Elem >::item(), GlobalMaster::modifyAppliedForces(), GlobalMaster::modifyForcedAtoms(), GlobalMaster::modifyGroupForces(), ResizeArray< Elem >::resize(), ResizeArray< Elem >::size(), and vmdforces.

Referenced by IMDOutput::gather_coordinates(), IMDOutput::gather_forces(), and IMDOutput::gather_velocities().

                                {
  if ((IMDversion == IMDversion_t::IMDv2) ||
      (IMDwait && !clients.size())) {
    // Check for incoming connections
    imd_connection();
  }

  if (IMDversion == IMDversion_t::IMDv2) {
  /* clear out the requested forces first! */
  if (!IMDignore && !IMDignoreForces) {
    modifyAppliedForces().resize(0);
    modifyForcedAtoms().resize(0);
    modifyGroupForces().resize(0);
  }

  // Assume for now that the only thing we get from VMD is a set of forces.
  // Later we'll want to look for and implement more sophisticated control
  // parameters. ie have a specified protocol

  // Check/get new forces from VMD
  get_vmd_forces();

  // Right now I don't check to see if any new forces were obtained.
  // An optimization would be cache the results message.  However, there
  // would still be copying since it looks like the messages get deleted
  // by the receiver.

  /* set our arrays to be big enough to hold all of the forces */
  int num = vmdforces.size();

  DebugM(2,"Setting " << num << " forces.\n");
  
  if (!IMDignore && !IMDignoreForces) {
    modifyForcedAtoms().resize(num);
    modifyAppliedForces().resize(num);
  
    int i;
    UniqueSortedArray<vmdforce>::iterator v_i = vmdforces.begin();
    for ( i = 0; i < num; ++i, ++v_i) {
      modifyForcedAtoms().item(i) = v_i->index;
      modifyAppliedForces().item(i) = v_i->force;
    }
  }
  }
}

get_vmd_forces()

void GlobalMasterIMD::get_vmd_forces ( )

protected

Definition at line 225 of file GlobalMasterIMD.C.

References clients, ResizeArray< Elem >::del(), endi(), vmdforce::force, iINFO(), Node::imd, imd_connection(), IMD_DISCONNECT, IMD_ENERGIES, IMD_FCOORDS, IMD_IOERROR, IMD_KILL, IMD_MDCOMM, IMD_PAUSE, imd_recv_energies(), imd_recv_fcoords(), imd_recv_header(), imd_recv_mdcomm(), IMD_RESUME, IMD_TRATE, IMD_WAIT, IMDignore, IMDignoreForces, IMDv2, IMDv3, IMDversion, IMDwait, SimParameters::IMDwait, vmdforce::index, iout, iWARN(), NAMD_quit(), Node::Object(), IMDOutput::set_transrate(), Node::simParameters, ResizeArray< Elem >::size(), vmdforces, vmdsock_destroy(), vmdsock_selread(), Vector::x, Vector::y, and Vector::z.

Referenced by calculate(), and IMDOutput::get_imd_packet().

                                     {
  IMDType type;
  int32 length;
  int32 *vmd_atoms;
  float *vmd_forces;
  int paused = 0;
  int warned = 0;
  vmdforce *vtest, vnew;

  // Loop through each socket one at a time.  By doing this, rather than 
  // polling all sockets at once, NAMD only has to keep up with one IMD
  // connection; if it tried to read from all of them, it could more easily
  // fall behind and never finish draining all the sockets.
  // It would be better to have a system where VMD couldn't DOS NAMD by 
  // spamming it with messages, but in practice NAMD is able to keep up with 
  // VMD's send rate.
  for (int i_client=0; i_client<clients.size(); i_client++) {
    void *clientsock = clients[i_client];
    while (vmdsock_selread(clientsock,0) > 0 || paused) {  // Drain the socket
      type = imd_recv_header(clientsock, &length);
      switch (type) {
        case IMD_MDCOMM:
          // Expect the msglength to give number of indicies, and the data
          // message to consist of first the indicies, then the coordinates
          // in xyz1 xyz2... format.
          vmd_atoms = new int32[length];
          vmd_forces = new float[3*length];
          if (imd_recv_mdcomm(clientsock, length, vmd_atoms, vmd_forces)) {
            iout << iWARN <<
              "Error reading IMD forces, killing connection\n" << endi;
            goto vmdDestroySocket;
          } 
          if (IMDversion == IMDversion_t::IMDv3) {
            iout << iWARN << "Ignoring IMD forces as receiving forces is not supported in IMDv3 as of now\n" << endi;
          }
          else if (IMDignore || IMDignoreForces)  {
            if ( ! warned ) {
              warned = 1;
              char option[16];
              if (IMDignore) strcpy(option, "IMDignore");
              else strcpy(option, "IMDignoreForces");  
              iout << iWARN << "Ignoring IMD forces due to " << option << "\n" << endi;
            }
          } else {
            for (int i=0; i<length; i++) {
              vnew.index = vmd_atoms[i];
              if ( (vtest=vmdforces.find(vnew)) != NULL) {
                // find was successful, so overwrite the old force values
                if (vmd_forces[3*i] != 0.0f || vmd_forces[3*i+1] != 0.0f
                    || vmd_forces[3*i+2] != 0.0f) {
                  vtest->force.x = vmd_forces[3*i];
                  vtest->force.y = vmd_forces[3*i+1];
                  vtest->force.z = vmd_forces[3*i+2];
                } else {
                  // or delete it from the list if the new force is ZERO
                  vmdforces.del(vnew);
                }
              }
              else {
                // Create a new entry in the table if the new force isn't ZERO
                if (vmd_forces[3*i] != 0.0f || vmd_forces[3*i+1] != 0.0f
                    || vmd_forces[3*i+2] != 0.0f) {
                  vnew.force.x = vmd_forces[3*i];
                  vnew.force.y = vmd_forces[3*i+1];
                  vnew.force.z = vmd_forces[3*i+2];
                  vmdforces.add(vnew);
                }
              }
            } 
          }
          delete [] vmd_atoms;
          delete [] vmd_forces;
          break;
        case IMD_TRATE:
          iout << iINFO << "Setting transfer rate to " << length<<'\n'<<endi;   
          Node::Object()->imd->set_transrate(length);
          break;
        case IMD_PAUSE:
          if (IMDignore) {
            iout << iWARN << "Ignoring IMD pause due to IMDignore\n" << endi;
            break;
          }
          if (IMDversion == IMDversion_t::IMDv2) {
            if ( paused ) {
              iout << iINFO << "Resuming IMD\n" << endi;
              IMDwait = Node::Object()->simParameters->IMDwait;
            }
            paused = ! paused;
            if ( paused ) {
              iout << iINFO << "Pausing IMD\n" << endi;
              IMDwait = 1;
            }
          } else if (IMDversion == IMDversion_t::IMDv3) {
            if ( paused ) {
              iout << iINFO << "Already paused\n" << endi;
            }
            if ( ! paused ) {
              iout << iINFO << "Pausing IMD\n" << endi;
              paused = ! paused;
            }
          }
          break;
        case IMD_RESUME:
          if (IMDversion == IMDversion_t::IMDv3) {
            if ( paused ) {
              iout << iINFO << "Resuming IMD\n" << endi;
            }
            paused = ! paused;
          }
          break;
        case IMD_IOERROR:
          iout << iWARN << "IMD connection lost\n" << endi;
        case IMD_DISCONNECT:
          iout << iINFO << "IMD connection detached\n" << endi;
          vmdDestroySocket:
          vmdsock_destroy(clientsock);
          clients.del(i_client);
          // Adjust index to account for the deleted client
          i_client--;
          // Remove any paused state before moving onto next client
          if ( paused ) paused = ! paused;
          // Enable the MD to continue after detach if IMD is v2
          if (IMDwait && IMDversion == IMDversion_t::IMDv2) IMDwait = 0;
          if (IMDwait && !clients.size()) imd_connection();
          goto vmdEnd;
        case IMD_KILL:
          if (IMDignore) {
            iout << iWARN << "Ignoring IMD kill due to IMDignore\n" << endi;
            break;
          }
          NAMD_quit("Received IMD kill from client\n");
          break;
        case IMD_ENERGIES:
          IMDEnergies junk;
          imd_recv_energies(clientsock, &junk);
          break;
        case IMD_FCOORDS:
          vmd_forces = new float[3*length];
          imd_recv_fcoords(clientsock, length, vmd_forces);
          delete [] vmd_forces;
          break;
        case IMD_WAIT:
          if (IMDversion == IMDversion_t::IMDv3) {
            IMDwait = length;
            iout << iINFO << "IMD set to " << (IMDwait ? "wait" : "not wait") << " for incoming connection" << '\n' << endi;
          }
          break;
        default: ;
      }
    }
  vmdEnd: ;
  }
}

imd_connection()

void GlobalMasterIMD::imd_connection ( )

protected

Definition at line 152 of file GlobalMasterIMD.C.

References ResizeArray< Elem >::add(), clients, endi(), iINFO(), IMDsendsettings, IMDversion, IMDwait, iout, iWARN(), my_imd_connect(), ResizeArray< Elem >::size(), sock, vmdsock_accept(), vmdsock_destroy(), and vmdsock_selread().

Referenced by calculate(), IMDOutput::get_imd_packet(), and get_vmd_forces().

                                     {
  // check for incoming connection
  do {
  int rc;
  if (IMDwait && !clients.size()) {
    iout << iINFO << "INTERACTIVE MD AWAITING CONNECTION\n" << endi;
    do { rc = vmdsock_selread(sock, 3600); } while (rc <= 0);
  } else {
    rc = vmdsock_selread(sock, 0);
  } 
  if (rc > 0) {
    void *clientsock = vmdsock_accept(sock);
    if (!clientsock) {
      iout << iWARN << "IMD socket accept failed\n" << endi;
    } else {
      if (!my_imd_connect(clientsock, IMDversion, &IMDsendsettings)) {
        iout << iWARN << "IMD connection failed\n" << endi;
        vmdsock_destroy(clientsock);
      } else {
        iout << iINFO << "IMD connection opened\n" <<endi;      
        clients.add(clientsock);
      }
    }
  }
  } while (IMDwait && !clients.size());
}

send_box()

void GlobalMasterIMD::send_box

(

IMDBox *

box

)

Definition at line 507 of file GlobalMasterIMD.C.

References clients, imd_send_box(), IMDv3TimeoutSeconds, NAMD_die(), ResizeArray< Elem >::size(), and vmdsock_selwrite().

Referenced by IMDOutput::gather_box().

                                          {
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    /*
     * Only IMDv3 may require the box.
     */
    if (!clientsock) continue;
    else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
      const std::string error =
        std::string{"IMDv3: GlobalMasterIMD::send_box socket timeout in "} +
        std::to_string(IMDv3TimeoutSeconds) + "\n";
      NAMD_die(error.c_str());
    }
    imd_send_box(clientsock, box);
  }
}

send_energies()

void GlobalMasterIMD::send_energies

(

IMDEnergies *

energies

)

Definition at line 379 of file GlobalMasterIMD.C.

References clients, imd_send_energies(), IMDv2, IMDv3, IMDv3TimeoutSeconds, SimParameters::IMDversion, NAMD_die(), Node::Object(), Node::simParameters, ResizeArray< Elem >::size(), and vmdsock_selwrite().

Referenced by IMDOutput::gather_energies().

                                                         {
  const SimParameters *simparams = Node::Object()->simParameters;
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    if (simparams->IMDversion == IMDversion_t::IMDv2) {
      if (!clientsock || !vmdsock_selwrite(clientsock,0)) continue;
    } else if (simparams->IMDversion == IMDversion_t::IMDv3) {
      /* NOTE (from Lawson Woods):
       * If vmdsock_selwrite returns 0, indicating that the socket
       * isn't immediately available (within 0 seconds), the above
       * IMDv2 code just doesn't send the packet.
       * But in IMDv3, packets aren't skippable, the simulation
       * engine has to wait until the socket is ready.
       */
      if (!clientsock) continue;
      else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
        const std::string error =
          std::string{"IMDv3: GlobalMasterIMD::send_energies socket timeout in "} +
          std::to_string(IMDv3TimeoutSeconds) + "\n";
        NAMD_die(error.c_str());
      }
    }
    imd_send_energies(clientsock, energies);
  }
}

send_fcoords()

void GlobalMasterIMD::send_fcoords	(	int	N,
		FloatVector *	coords
	)

Definition at line 405 of file GlobalMasterIMD.C.

References clients, coords, coordtmp, coordtmpsize, imd_send_fcoords(), IMDv2, IMDv3, IMDv3TimeoutSeconds, SimParameters::IMDversion, NAMD_die(), Node::Object(), Node::simParameters, ResizeArray< Elem >::size(), and vmdsock_selwrite().

Referenced by IMDOutput::gather_coordinates().

                                                             {
  const SimParameters *simparams = Node::Object()->simParameters;
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    if (simparams->IMDversion == IMDversion_t::IMDv2) {
      if (!clientsock || !vmdsock_selwrite(clientsock,0)) continue;
    } else if (simparams->IMDversion == IMDversion_t::IMDv3) {
      /* NOTE (from Lawson Woods):
       * If vmdsock_selwrite returns 0, indicating that the socket
       * isn't immediately available (within 0 seconds), the above
       * IMDv2 code just doesn't send the packet.
       * But in IMDv3, packets aren't skippable, the simulation
       * engine has to wait until the socket is ready.
       */
      if (!clientsock) continue;
      else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
        const std::string error =
          std::string{"IMDv3: GlobalMasterIMD::send_fcoords socket timeout in "} +
          std::to_string(IMDv3TimeoutSeconds) + "\n";
        NAMD_die(error.c_str());
      }
    }
    if (sizeof(FloatVector) == 3*sizeof(float)) {
      imd_send_fcoords(clientsock, N, (float *)coords);
    } else {
      if (coordtmpsize < N) {
        if (coordtmp) delete [] coordtmp;
        coordtmp = new float[3*N];
        coordtmpsize = N;
      }
      for (int i=0; i<N; i++) {
        coordtmp[3*i] = coords[i].x; 
        coordtmp[3*i+1] = coords[i].y; 
        coordtmp[3*i+2] = coords[i].z; 
      } 
      imd_send_fcoords(clientsock, N, coordtmp);
    }
  }
}

send_forces()

void GlobalMasterIMD::send_forces	(	int	N,
		FloatVector *	forces
	)

Definition at line 476 of file GlobalMasterIMD.C.

References clients, forcetmp, forcetmpsize, imd_send_forces(), IMDv3TimeoutSeconds, NAMD_die(), ResizeArray< Elem >::size(), vmdsock_selwrite(), FloatVector::x, FloatVector::y, and FloatVector::z.

Referenced by IMDOutput::gather_forces().

                                                            {
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    /*
     * Only IMDv3 may require the forces.
     */
    if (!clientsock) continue;
    else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
      const std::string error =
        std::string{"IMDv3: GlobalMasterIMD::send_forces socket timeout in "} +
        std::to_string(IMDv3TimeoutSeconds) + "\n";
      NAMD_die(error.c_str());
    }
    if (sizeof(FloatVector) == 3*sizeof(float)) {
      imd_send_forces(clientsock, N, (float *)forces);
    } else {
      if (forcetmpsize < N) {
        if (forcetmp) delete [] forcetmp;
        forcetmp = new float[3*N];
        forcetmpsize = N;
      }
      for (int i=0; i<N; i++) {
        forcetmp[3*i] = forces[i].x; 
        forcetmp[3*i+1] = forces[i].y; 
        forcetmp[3*i+2] = forces[i].z; 
      } 
      imd_send_forces(clientsock, N, forcetmp);
    }
  }
}

send_time()

void GlobalMasterIMD::send_time

(

IMDTime *

time

)

Definition at line 524 of file GlobalMasterIMD.C.

References clients, imd_send_time(), IMDv3TimeoutSeconds, NAMD_die(), ResizeArray< Elem >::size(), and vmdsock_selwrite().

Referenced by IMDOutput::gather_time().

                                             {
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    /*
     * Only IMDv3 may require the time.
     */
    if (!clientsock) continue;
    else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
      const std::string error =
        std::string{"IMDv3: GlobalMasterIMD::send_time socket timeout in "} +
        std::to_string(IMDv3TimeoutSeconds) + "\n";
      NAMD_die(error.c_str());
    }
    imd_send_time(clientsock, time);
  }
}

send_velocities()

void GlobalMasterIMD::send_velocities	(	int	N,
		FloatVector *	velocities
	)

Definition at line 445 of file GlobalMasterIMD.C.

References clients, imd_send_velocities(), IMDv3TimeoutSeconds, NAMD_die(), ResizeArray< Elem >::size(), veltmp, veltmpsize, vmdsock_selwrite(), FloatVector::x, FloatVector::y, and FloatVector::z.

Referenced by IMDOutput::gather_velocities().

                                                                    {
  for (int i=0; i<clients.size(); i++) {
    void *clientsock = clients[i];
    /*
     * Only IMDv3 may require the velocities.
     */
    if (!clientsock) continue;
    else if (!vmdsock_selwrite(clientsock, IMDv3TimeoutSeconds)) {
      const std::string error =
        std::string{"IMDv3: GlobalMasterIMD::send_velocities socket timeout in "} +
        std::to_string(IMDv3TimeoutSeconds) + "\n";
      NAMD_die(error.c_str());
    }
    if (sizeof(FloatVector) == 3*sizeof(float)) {
      imd_send_velocities(clientsock, N, (float *)velocities);
    } else {
      if (veltmpsize < N) {
        if (veltmp) delete [] veltmp;
        veltmp = new float[3*N];
        veltmpsize = N;
      }
      for (int i=0; i<N; i++) {
        veltmp[3*i] = velocities[i].x; 
        veltmp[3*i+1] = velocities[i].y; 
        veltmp[3*i+2] = velocities[i].z; 
      } 
      imd_send_velocities(clientsock, N, veltmp);
    }
  }
}

Friends And Related Function Documentation

IMDOutput

friend class IMDOutput

friend

Definition at line 34 of file GlobalMasterIMD.h.

Member Data Documentation

clients

ResizeArray<void *> GlobalMasterIMD::clients

protected

Definition at line 66 of file GlobalMasterIMD.h.

Referenced by calculate(), get_vmd_forces(), imd_connection(), send_box(), send_energies(), send_fcoords(), send_forces(), send_time(), send_velocities(), and ~GlobalMasterIMD().

coordtmp

float* GlobalMasterIMD::coordtmp

protected

Definition at line 69 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), send_fcoords(), and ~GlobalMasterIMD().

coordtmpsize

int GlobalMasterIMD::coordtmpsize

protected

Definition at line 70 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_fcoords().

forcetmp

float* GlobalMasterIMD::forcetmp

protected

Definition at line 75 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), send_forces(), and ~GlobalMasterIMD().

forcetmpsize

int GlobalMasterIMD::forcetmpsize

protected

Definition at line 76 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_forces().

IMDignore

int GlobalMasterIMD::IMDignore

protected

Definition at line 54 of file GlobalMasterIMD.h.

Referenced by calculate(), get_vmd_forces(), GlobalMasterIMD(), and IMDOutput::use_imd().

IMDignoreForces

int GlobalMasterIMD::IMDignoreForces

protected

Definition at line 57 of file GlobalMasterIMD.h.

Referenced by calculate(), get_vmd_forces(), GlobalMasterIMD(), and IMDOutput::use_imd().

IMDsendsettings

IMDSessionInfo GlobalMasterIMD::IMDsendsettings

protected

Definition at line 60 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and imd_connection().

IMDv3TimeoutSeconds

int GlobalMasterIMD::IMDv3TimeoutSeconds

protected

Definition at line 78 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), send_box(), send_energies(), send_fcoords(), send_forces(), send_time(), and send_velocities().

IMDversion

int GlobalMasterIMD::IMDversion

protected

Definition at line 48 of file GlobalMasterIMD.h.

Referenced by calculate(), get_vmd_forces(), GlobalMasterIMD(), and imd_connection().

IMDwait

int GlobalMasterIMD::IMDwait

protected

Definition at line 51 of file GlobalMasterIMD.h.

Referenced by calculate(), get_vmd_forces(), GlobalMasterIMD(), and imd_connection().

sock

void* GlobalMasterIMD::sock

protected

Definition at line 63 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), imd_connection(), and ~GlobalMasterIMD().

veltmp

float* GlobalMasterIMD::veltmp

protected

Definition at line 72 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), send_velocities(), and ~GlobalMasterIMD().

veltmpsize

int GlobalMasterIMD::veltmpsize

protected

Definition at line 73 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_velocities().

---

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

• GlobalMasterIMD.h
• GlobalMasterIMD.C