class MultiGeneratorAgent(AgentMET4FOF): def init_parameters(self): self.sine_stream = SineGenerator() self.cos_stream = CosineGenerator() def agent_loop(self): if self.current_state == "Running": sine_data = self.sine_stream.next_sample() #dictionary cosine_data = self.sine_stream.next_sample() #dictionary self.send_output(sine_data['x'], channel="sine") self.send_output(cosine_data['x'], channel="cosine")
class NoisySineGeneratorAgent(AgentMET4FOF): """An agent streaming a sine signal Takes samples from the :py:mod:`SineGenerator` and pushes them sample by sample to connected agents via its output channel. """ # The datatype of the stream will be SineGenerator. _sine_stream: SineGenerator def init_parameters(self): """Initialize the input data Initialize the input data stream as an instance of the :py:mod:`SineGenerator` class """ self._sine_stream = SineGenerator() def agent_loop(self): """Model the agent's behaviour On state *Running* the agent will extract sample by sample the input data streams content and push it via invoking :py:method:`AgentMET4FOF.send_output`. """ if self.current_state == "Running": sine_data = self._sine_stream.next_sample() # dictionary sine_data["quantities"] = sine_data["quantities"] + np.random.rand( *sine_data["quantities"].shape) self.send_output(sine_data)
class ParameterisedSineGeneratorAgent(AgentMET4FOF): """An agent streaming a sine signal Takes samples from the :py:mod:`SineGenerator` and pushes them sample by sample to connected agents via its output channel. """ # The datatype of the stream will be SineGenerator. _sine_stream: SineGenerator # dictionary of possible parameter options for init # every {key:iterable} will be displayed on the dashboard as a dropdown # NOTE: Currently supports keyword arguments only. parameter_choices = { "amplitude": {0, 1, 2, 3, 4, 5, 6}, "frequency": {1, 2, 3} } stylesheet = "ellipse" def init_parameters(self, amplitude=1.0, frequency=0.5): """Initialize the input data Initialize the input data stream as an instance of the :py:mod:`SineGenerator` class """ self.frequency = frequency self.amplitude = amplitude self._sine_stream = SineGenerator() def agent_loop(self): """Model the agent's behaviour On state *Running* the agent will extract sample by sample the input data streams content and push it via invoking :py:method:`AgentMET4FOF.send_output`. """ if self.current_state == "Running": sine_data = self._sine_stream.next_sample() # dictionary self.send_output(sine_data["quantities"])
class SineGeneratorAgent(AgentMET4FOF): def init_parameters(self): self.stream = SineGenerator() def agent_loop(self): if self.current_state == "Running": sine_data = self.stream.next_sample() #dictionary self.send_output(sine_data['x'])
class BufferSineGeneratorAgent(AgentMET4FOF): """An agent streaming a sine signal Takes samples from the :py:mod:`SineGenerator` and pushes them sample by sample to connected agents via its output channel. """ # The datatype of the stream will be SineGenerator. _sine_stream: SineGenerator def init_parameters(self): """Initialize the input data Initialize the input data stream as an instance of the :py:mod:`SineGenerator` class """ self._sine_stream = SineGenerator() def agent_loop(self): """Model the agent's behaviour On state *Running* the agent will extract sample by sample the input data streams content and push it via invoking :py:method:`AgentMET4FOF.send_output`. """ if self.current_state == "Running": sine_data = self._sine_stream.next_sample() # dictionary # store buffer with received data from input agent # By default, the AgentBuffer is a FIFO buffer and when new n entries are added to a filled buffer, # n entries from the left of buffer will be automatically removed. # Note: self.buffer.store and self.buffer_store works the same way, but self.buffer_store has an additional `log_info` to it, # so it will print out its content if logging is enabled. self.buffer.store( agent_from=self.name, data=sine_data ) # equivalent to self.buffer_store but without logging. # check if buffer is filled up, then send out computed mean on the buffer if self.buffer.buffer_filled(self.name): # access buffer content by accessing its key, it works like a dictionary # the actual dictionary is stored in self.buffer.buffer buffer_content = self.buffer[self.name] buffer_quantities = buffer_content["quantities"] buffer_time = buffer_content["time"] # print out the buffer content self.log_info("buffer_content:" + str(buffer_content)) # send out processed data # note that 'time' is a special keyword for MonitorAgent's default plotting behaviour # which renders it as the x-axis in a time-series graph # for more customisation, see the tutorials on custom plotting. self.send_output({"Sine": buffer_quantities, "time": buffer_time}) # clear buffer self.buffer.clear(self.name)
class TimeSineGeneratorAgent(AgentMET4FOF): def init_parameters(self): self.stream = SineGenerator() def agent_loop(self): if self.current_state == "Running": sine_data = self.stream.next_sample() # dictionary # read current time stamp current_time = datetime.today().strftime("%H:%M:%S") # send out data in form of dictionary {"Time","Y"} self.send_output({"Time": current_time, "Y": sine_data["quantities"]})
class SineGeneratorAgent(AgentMET4FOF): def init_parameters(self): self.stream = SineGenerator() def agent_loop(self): if self.current_state == "Running": sine_data = self.stream.next_sample() #dictionary self.buffer_store(agent_from=self.name, data=sine_data) # send out buffered data if the stored data has exceeded the buffer size if self.buffer_filled(self.name): self.send_output(self.buffer[self.name]) self.buffer_clear()
class SineGeneratorAgent(AgentMET4FOF): """An agent streaming a sine signal Takes samples from the :py:mod:`SineGenerator` and pushes them sample by sample to connected agents via its output channel. """ # The datatype of the stream will be SineGenerator. _sine_stream: SineGenerator def init_parameters(self, nested_output=False, scaler=1.0): """Initialize the input data Initialize the input data stream as an instance of the :py:mod:`SineGenerator` class """ self._sine_stream = SineGenerator() self.nested_output = nested_output self.scaler = scaler def agent_loop(self): """Model the agent's behaviour On state *Running* the agent will extract sample by sample the input data streams content and push it via invoking :py:method:`AgentMET4FOF.send_output`. """ if self.current_state == "Running": sine_data = self._sine_stream.next_sample() # dictionary if self.nested_output: self.send_output({ "Sensor1": sine_data["quantities"] * self.scaler, "Sensor2": sine_data["quantities"] * self.scaler + 1.1, }) else: self.send_output(sine_data["quantities"] * self.scaler)