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

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 ( )

Definition at line 55 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::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");
 
   Node::Object()->imd->use_imd(this);
 
   IMDv3TimeoutSeconds = 60;
 }

◆ ~GlobalMasterIMD()

GlobalMasterIMD::~GlobalMasterIMD ( )

Definition at line 94 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 128 of file GlobalMasterIMD.C.

References ResizeArray< Elem >::add(), clients, DebugM, endi(), vmdforce::force, get_vmd_forces(), iINFO(), IMDignore, IMDignoreForces, IMDsendsettings, IMDversion, IMDwait, vmdforce::index, iout, ResizeArray< Elem >::item(), iWARN(), GlobalMaster::modifyAppliedForces(), GlobalMaster::modifyForcedAtoms(), GlobalMaster::modifyGroupForces(), my_imd_connect(), ResizeArray< Elem >::resize(), ResizeArray< Elem >::size(), sock, vmdforces, vmdsock_accept(), vmdsock_destroy(), and vmdsock_selread().

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

                                 {
   /* clear out the requested forces first! */
   if (!IMDignore && !IMDignoreForces) {
     modifyAppliedForces().resize(0);
     modifyForcedAtoms().resize(0);
     modifyGroupForces().resize(0);
   }
 
   // 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());
 
   // 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 191 of file GlobalMasterIMD.C.

References clients, ResizeArray< Elem >::del(), endi(), vmdforce::force, iINFO(), Node::imd, 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().

                                      {
   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 (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);
           // Enable the MD to continue after detach if IMD is v2
           if (IMDversion == IMDversion_t::IMDv2) {
             if (IMDwait) IMDwait = 0;
           }
           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: ;
   }
 }

◆ send_box()

void GlobalMasterIMD::send_box ( IMDBox * box )

Definition at line 467 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 339 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 365 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 436 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 484 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 405 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 60 of file GlobalMasterIMD.h.

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

◆ coordtmp

float* GlobalMasterIMD::coordtmp

protected

Definition at line 63 of file GlobalMasterIMD.h.

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

◆ coordtmpsize

int GlobalMasterIMD::coordtmpsize

protected

Definition at line 64 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_fcoords().

◆ forcetmp

float* GlobalMasterIMD::forcetmp

protected

Definition at line 69 of file GlobalMasterIMD.h.

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

◆ forcetmpsize

int GlobalMasterIMD::forcetmpsize

protected

Definition at line 70 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_forces().

◆ IMDignore

int GlobalMasterIMD::IMDignore

protected

Definition at line 48 of file GlobalMasterIMD.h.

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

◆ IMDignoreForces

int GlobalMasterIMD::IMDignoreForces

protected

Definition at line 51 of file GlobalMasterIMD.h.

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

◆ IMDsendsettings

IMDSessionInfo GlobalMasterIMD::IMDsendsettings

protected

Definition at line 54 of file GlobalMasterIMD.h.

Referenced by calculate(), and GlobalMasterIMD().

◆ IMDv3TimeoutSeconds

int GlobalMasterIMD::IMDv3TimeoutSeconds

protected

Definition at line 72 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 42 of file GlobalMasterIMD.h.

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

◆ IMDwait

int GlobalMasterIMD::IMDwait

protected

Definition at line 45 of file GlobalMasterIMD.h.

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

◆ sock

void* GlobalMasterIMD::sock

protected

Definition at line 57 of file GlobalMasterIMD.h.

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

◆ veltmp

float* GlobalMasterIMD::veltmp

protected

Definition at line 66 of file GlobalMasterIMD.h.

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

◆ veltmpsize

int GlobalMasterIMD::veltmpsize

protected

Definition at line 67 of file GlobalMasterIMD.h.

Referenced by GlobalMasterIMD(), and send_velocities().

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

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ GlobalMasterIMD()

◆ ~GlobalMasterIMD()

Member Function Documentation

◆ calculate()

◆ get_vmd_forces()

◆ send_box()

◆ send_energies()

◆ send_fcoords()

◆ send_forces()

◆ send_time()

◆ send_velocities()

Friends And Related Function Documentation

◆ IMDOutput

Member Data Documentation

◆ clients

◆ coordtmp

◆ coordtmpsize

◆ forcetmp

◆ forcetmpsize

◆ IMDignore

◆ IMDignoreForces

◆ IMDsendsettings

◆ IMDv3TimeoutSeconds

◆ IMDversion

◆ IMDwait

◆ sock

◆ veltmp

◆ veltmpsize