def __init__(self, latency=1.0, name="", pars=None, dopbc=True, active=np.array([-1]), interface=None): """Initialises FFSocket. Args: latency: The number of seconds the socket will wait before updating the client list. name: The name of the forcefield. pars: A dictionary used to initialize the forcefield, if required. Of the form {'name1': value1, 'name2': value2, ... }. dopbc: Decides whether or not to apply the periodic boundary conditions before sending the positions to the client code. interface: The object used to create the socket used to interact with the client codes. """ # a socket to the communication library is created or linked super(FFSocket, self).__init__(latency, name, pars, dopbc, active) if interface is None: self.socket = InterfaceSocket() else: self.socket = interface self.socket.requests = self.requests
def fetch(self): """Creates a ForceSocket object. Returns: A ForceSocket object with the correct socket parameters. """ if self.threaded.fetch() == False: raise ValueError("FFSockets cannot poll without threaded mode.") # just use threaded throughout return FFSocket( pars=self.parameters.fetch(), name=self.name.fetch(), latency=self.latency.fetch(), dopbc=self.pbc.fetch(), active=self.activelist.fetch(), threaded=self.threaded.fetch(), interface=InterfaceSocket( address=self.address.fetch(), port=self.port.fetch(), slots=self.slots.fetch(), mode=self.mode.fetch(), timeout=self.timeout.fetch(), match_mode=self.matching.fetch(), exit_on_disconnect=self.exit_on_disconnect.fetch()))
def fetch(self): """Creates a ForceSocket object. Returns: A ForceSocket object with the correct socket parameters. """ return FFSocket(pars = self.parameters.fetch(), name = self.name.fetch(), latency = self.latency.fetch(), dopbc = self.pbc.fetch(), interface=InterfaceSocket(address=self.address.fetch(), port=self.port.fetch(), slots=self.slots.fetch(), mode=self.mode.fetch(), timeout=self.timeout.fetch() ) )
def __init__(self, pars=None, interface=None): """Initializes FFSocket. Args: pars: Optional dictionary, giving the parameters needed by the driver. interface: Optional Interface object, which contains the socket. """ # a socket to the communication library is created or linked super(FFSocket,self).__init__() if interface is None: self.socket = InterfaceSocket() else: self.socket = interface if pars is None: self.pars = {} else: self.pars = pars self.request = None
class FFSocket(ForceField): """Interface between the PIMD code and a socket for a single replica. Deals with an individual replica of the system, obtaining the potential force and virial appropriate to this system. Deals with the distribution of jobs to the interface. Attributes: socket: The interface object which contains the socket through which communication between the forcefield and the driver is done. """ def __init__(self, latency=1.0, name="", pars=None, dopbc=True, active=np.array([-1]), interface=None): """Initialises FFSocket. Args: latency: The number of seconds the socket will wait before updating the client list. name: The name of the forcefield. pars: A dictionary used to initialize the forcefield, if required. Of the form {'name1': value1, 'name2': value2, ... }. dopbc: Decides whether or not to apply the periodic boundary conditions before sending the positions to the client code. interface: The object used to create the socket used to interact with the client codes. """ # a socket to the communication library is created or linked super(FFSocket, self).__init__(latency, name, pars, dopbc, active) if interface is None: self.socket = InterfaceSocket() else: self.socket = interface self.socket.requests = self.requests def poll(self): """Function to check the status of the client calculations.""" self.socket.poll() def run(self): """Spawns a new thread.""" self.socket.open() super(FFSocket, self).run() def stop(self): """Closes the socket and the thread.""" super(FFSocket, self).stop() if self._thread is not None: # must wait until loop has ended before closing the socket self._thread.join() self.socket.close()
class FFSocket(ForceField): """Interface between the PIMD code and a socket for a single replica. Deals with an individual replica of the system, obtaining the potential force and virial appropriate to this system. Deals with the distribution of jobs to the interface. Attributes: socket: The interface object which contains the socket through which communication between the forcefield and the driver is done. """ def __init__(self, latency=1.0, name="", pars=None, dopbc=True, active=np.array([-1]), threaded=True, interface=None, matching="auto"): """Initialises FFSocket. Args: latency: The number of seconds the socket will wait before updating the client list. name: The name of the forcefield. pars: A dictionary used to initialize the forcefield, if required. Of the form {'name1': value1, 'name2': value2, ... }. dopbc: Decides whether or not to apply the periodic boundary conditions before sending the positions to the client code. interface: The object used to create the socket used to interact with the client codes. """ # a socket to the communication library is created or linked super(FFSocket, self).__init__(latency, name, pars, dopbc, active, threaded) if interface is None: self.socket = InterfaceSocket() else: self.socket = interface self.socket.requests = self.requests def poll(self): """Function to check the status of the client calculations.""" self.socket.poll() def start(self): """Spawns a new thread.""" self.socket.open() super(FFSocket, self).start() def stop(self): """Closes the socket and the thread.""" super(FFSocket, self).stop() if self._thread is not None: # must wait until loop has ended before closing the socket self._thread.join() self.socket.close()
def __init__(self, pars=None, interface=None): """Initialises FFSocket. Args: pars: Optional dictionary, giving the parameters needed by the driver. interface: Optional Interface object, which contains the socket. """ # a socket to the communication library is created or linked super(FFSocket,self).__init__() if interface is None: self.socket = InterfaceSocket() else: self.socket = interface if pars is None: self.pars = {} else: self.pars = pars self.request = None
def __init__(self, latency=1.0, name="", pars=None, dopbc=True, active=np.array([-1]), threaded=True, interface=None, matching="auto"): """Initialises FFSocket. Args: latency: The number of seconds the socket will wait before updating the client list. name: The name of the forcefield. pars: A dictionary used to initialize the forcefield, if required. Of the form {'name1': value1, 'name2': value2, ... }. dopbc: Decides whether or not to apply the periodic boundary conditions before sending the positions to the client code. interface: The object used to create the socket used to interact with the client codes. """ # a socket to the communication library is created or linked super(FFSocket, self).__init__(latency, name, pars, dopbc, active, threaded) if interface is None: self.socket = InterfaceSocket() else: self.socket = interface self.socket.requests = self.requests
class FFSocket(ForceField): """Interface between the PIMD code and the socket for a single replica. Deals with an individual replica of the system, obtaining the potential force and virial appropriate to this system. Deals with the distribution of jobs to the interface. Attributes: parameters: A dictionary of the parameters used by the driver. Of the form {'name': value}. socket: The interface object which contains the socket through which communication between the forcefield and the driver is done. request: During the force calculation step this holds a dictionary containing the relevant data for determining the progress of the step. Of the form {'atoms': atoms, 'cell': cell, 'pars': parameters, 'status': status, 'result': result, 'id': bead id, 'start': starting time}. """ def __init__(self, pars=None, interface=None): """Initialises FFSocket. Args: pars: Optional dictionary, giving the parameters needed by the driver. interface: Optional Interface object, which contains the socket. """ # a socket to the communication library is created or linked super(FFSocket,self).__init__() if interface is None: self.socket = InterfaceSocket() else: self.socket = interface if pars is None: self.pars = {} else: self.pars = pars self.request = None def bind(self, atoms, cell): """Pass on the binding request from ForceBeads. Also makes sure to set the socket's softexit. Args: atoms: Atoms object from which the bead positions are taken. cell: Cell object from which the system box is taken. """ super(FFSocket,self).bind(atoms, cell) def copy(self): """Creates a deep copy without the bound objects. Used in ForceBeads to create a FFSocket for each replica of the system. Returns: A FFSocket object without atoms or cell attributes. """ # does not copy the bound objects # (i.e., the returned forcefield must be bound before use) return type(self)(self.pars, self.socket) def get_all(self): """Driver routine. When one of the force, potential or virial are called, this sends the atoms and cell to the driver through the interface, requesting that the driver does the calculation. This then waits until the driver is finished, and then returns the ufvx list. Returns: A list of the form [potential, force, virial, extra]. """ # this is converting the distribution library requests into [ u, f, v ] lists if self.request is None: self.request = self.socket.queue(self.atoms, self.cell, pars=self.pars, reqid=-1) while self.request["status"] != "Done": if self.request["status"] == "Exit": break time.sleep(self.socket.latency) if self.request["status"] == "Exit": softexit.trigger(" @Force: Requested returned a Exit status") # data has been collected, so the request can be released and a slot #freed up for new calculations self.socket.release(self.request) result = self.request["result"] self.request = None return result def queue(self, reqid=-1): """Sends the job to the interface queue directly. Allows the ForceBeads object to ask for the ufvx list of each replica directly without going through the get_all function. This allows all the jobs to be sent at once, allowing them to be parallelized. Args: reqid: An optional integer that indentifies requests of the same type, e.g. the bead index. """ if self.request is None and dget(self,"ufvx").tainted(): self.request = self.socket.queue(self.atoms, self.cell, pars=self.pars, reqid=reqid) def run(self): """Makes the socket start looking for driver codes. Tells the interface code to start the thread that looks for connection from the driver codes in a loop. Until this point no jobs can be queued. """ if not self.socket.started(): self.socket.start_thread() def stop(self): """Makes the socket stop looking for driver codes. Tells the interface code to stop the thread that looks for connection from the driver codes in a loop. After this point no jobs can be queued. """ if self.socket.started(): self.socket.end_thread()
class FFSocket(ForceField): """Interface between the PIMD code and the socket for a single replica. Deals with an individual replica of the system, obtaining the potential force and virial appropriate to this system. Deals with the distribution of jobs to the interface. Attributes: parameters: A dictionary of the parameters used by the driver. Of the form {'name': value}. socket: The interface object which contains the socket through which communication between the forcefield and the driver is done. request: During the force calculation step this holds a dictionary containing the relevant data for determining the progress of the step. Of the form {'atoms': atoms, 'cell': cell, 'pars': parameters, 'status': status, 'result': result, 'id': bead id, 'start': starting time}. """ def __init__(self, pars=None, interface=None): """Initializes FFSocket. Args: pars: Optional dictionary, giving the parameters needed by the driver. interface: Optional Interface object, which contains the socket. """ # a socket to the communication library is created or linked super(FFSocket,self).__init__() if interface is None: self.socket = InterfaceSocket() else: self.socket = interface if pars is None: self.pars = {} else: self.pars = pars self.request = None def bind(self, atoms, cell): """Pass on the binding request from ForceBeads. Also makes sure to set the socket's softexit. Args: atoms: Atoms object from which the bead positions are taken. cell: Cell object from which the system box is taken. """ super(FFSocket,self).bind(atoms, cell) def copy(self): """Creates a deep copy without the bound objects. Used in ForceBeads to create a FFSocket for each replica of the system. Returns: A FFSocket object without atoms or cell attributes. """ # does not copy the bound objects # (i.e., the returned forcefield must be bound before use) return type(self)(self.pars, self.socket) def get_all(self): """Driver routine. When one of the force, potential or virial are called, this sends the atoms and cell to the driver through the interface, requesting that the driver does the calculation. This then waits until the driver is finished, and then returns the ufvx list. Returns: A list of the form [potential, force, virial, extra]. """ # this is converting the distribution library requests into [ u, f, v ] lists if self.request is None: self.request = self.socket.queue(self.atoms, self.cell, pars=self.pars, reqid=-1) while self.request["status"] != "Done": if self.request["status"] == "Exit": break time.sleep(self.socket.latency) if self.request["status"] == "Exit": softexit.trigger(" @Force: Requested returned a Exit status") # data has been collected, so the request can be released and a slot #freed up for new calculations self.socket.release(self.request) result = self.request["result"] self.request = None return result def queue(self, reqid=-1): """Sends the job to the interface queue directly. Allows the ForceBeads object to ask for the ufvx list of each replica directly without going through the get_all function. This allows all the jobs to be sent at once, allowing them to be parallelized. Args: reqid: An optional integer that indentifies requests of the same type, e.g. the bead index. """ if self.request is None and dget(self,"ufvx").tainted(): self.request = self.socket.queue(self.atoms, self.cell, pars=self.pars, reqid=reqid) def run(self): """Makes the socket start looking for driver codes. Tells the interface code to start the thread that looks for connection from the driver codes in a loop. Until this point no jobs can be queued. """ if not self.socket.started(): self.socket.start_thread() def stop(self): """Makes the socket stop looking for driver codes. Tells the interface code to stop the thread that looks for connection from the driver codes in a loop. After this point no jobs can be queued. """ if self.socket.started(): self.socket.end_thread()
def test_interface(): """InterfaceSocket: startup.""" InterfaceSocket()