def on_message(self, headers, msg):
global stop_simulation
message = {}
try:
message_str = 'received message '+str(msg)
if fncs.is_initialized():
_send_simulation_status('RUNNING', message_str, 'DEBUG')
else:
_send_simulation_status('STARTED', message_str, 'DEBUG')
json_msg = yaml.safe_load(str(msg))
print("\n{}\n".format(json_msg['command']))
if json_msg['command'] == 'isInitialized':
message_str = 'isInitialized check: '+str(is_initialized)
if fncs.is_initialized():
_send_simulation_status('RUNNING', message_str, 'DEBUG')
else:
_send_simulation_status('STARTED', message_str, 'DEBUG')
message['command'] = 'isInitialized'
message['response'] = str(is_initialized)
if (simulation_id != None):
message['output'] = _get_fncs_bus_messages(simulation_id)
message_str = 'Added isInitialized output, sending message '+str(message)+' connection '+str(goss_connection)
if fncs.is_initialized():
_send_simulation_status('RUNNING', message_str, 'DEBUG')
else:
_send_simulation_status('STARTED', message_str, 'DEBUG')
message['timestamp'] = datetime.utcnow().microsecond
goss_connection.send(output_to_simulation_manager , json.dumps(message))
elif json_msg['command'] == 'update':
message['command'] = 'update'
_publish_to_fncs_bus(simulation_id, json.dumps(json_msg['input'])) #does not return
elif json_msg['command'] == 'nextTimeStep':
message['command'] = 'nextTimeStep'
current_time = json_msg['currentTime']
message_str = 'incrementing to '+str(current_time + 1)
_send_simulation_status('RUNNING', message_str, 'DEBUG')
_done_with_time_step(current_time) #current_time is incrementing integer 0 ,1, 2.... representing seconds
message_str = 'done with timestep '+str(current_time)
_send_simulation_status('RUNNING', message_str, 'DEBUG')
message['output'] = _get_fncs_bus_messages(simulation_id)
message['timestamp'] = datetime.utcnow().microsecond
response_msg = json.dumps(message)
goss_connection.send(output_to_goss_topic + "{}".format(simulation_id) , response_msg)
elif json_msg['command'] == 'stop':
message_str = 'Stopping the simulation'
_send_simulation_status('CLOSED', message_str, 'INFO')
stop_simulation = True
fncs.finalize()
except Exception as e:
message_str = 'Error in command '+str(e)
_send_simulation_status('ERROR', message_str, 'ERROR')
stop_simulation = True
if fncs.is_initialized():
fncs.die()
def on_error(self, headers, message):
global stop_simulation
message_str = 'Error in goss listener '+str(message)
_send_simulation_status('ERROR', message_str, 'ERROR')
stop_simulation = True
if fncs.is_initialized():
fncs.die()
def __register_federate(self):
self.__raise_if_not_installed()
cfg = """name = {0[name]}
time_delta = {0[time_delta]}
broker = {0[broker]}
""".format(
dict(name=self._federate_name,
broker=self._broker,
time_delta=self._time_delta))
if self._registered_fncs_topics:
cfg += "values"
for k, v in self._registered_fncs_topics.items():
cfg += "\n\t{}\n\t\ttopic = {}\n".format(k, v['fncs_topic'])
if v.get("default"):
cfg += "\t\tdefault = {}\n".format(v.get('default'))
if v.get("data_type"):
cfg += "\t\ttype = {}\n".format(v.get('data_type'))
if v.get("list"):
cfg += "\t\tlist = true\n"
_log.debug(cfg)
cfg = cfg.replace("\t", " ")
fncs.initialize(cfg)
_log.debug("After initialized!")
if not fncs.is_initialized():
raise RuntimeError("Intialization error for fncs.")
def _fncs_loop(self):
_log.info("Starting fncs loop")
self._simulation_started = True
while self._current_step < self._simulation_length:
# Block until the work is done here.
subKeys = fncs.get_events()
self._raise_if_error("After get_events")
self._current_values.clear()
for x in subKeys:
fncs_topic = self._registered_fncs_topics[x].get('fncs_topic')
self._current_values[fncs_topic] = fncs.get_value(x)
if not fncs.is_initialized():
fncs.die()
raise RuntimeError("FNCS unexpected error after get_values")
self._work_callback()
subKeys = fncs.get_events()
if len(subKeys) > 0:
for x in subKeys:
subkeyvalue = fncs.get_value(x)
volttron_topic = self._registered_fncs_topics[x].get('volttron_topic')
if volttron_topic:
self.pubsub().publish('pubsub', topic=volttron_topic, message=subkeyvalue)
# This allows other event loops to run
gevent.sleep(0.000000001)
self._simulation_complete = True
fncs.finalize()
if self._stop_agent_when_sim_complete:
self.core().stop()
def start_simulation(self):
""" Begin the main fncs loop
:return:
"""
self.__raise_if_not_installed()
if not fncs.is_initialized():
raise ValueError("intialized must be called before starting simulation")
gevent.spawn(self._fncs_loop)
# Allow the spawned greenlet to run.
gevent.sleep(0.1)
def register_with_fncs(self):
fncs_configuration = {
"name": "PythonListener{}".format(self.sim_id),
"time_delta": "1s",
"broker": self.broker_location,
"values": {
"{}".format(self.sim_id): {
"topic": self.subscription_topic,
"default": "{}",
"type": "JSON",
"list": "false"
}
}
}
configuration_zpl = (
'name = {0}\n'.format(fncs_configuration['name']) +
'time_delta = {0}\n'.format(fncs_configuration['time_delta']) +
'broker = {0}\nvalues'.format(fncs_configuration['broker']))
for x in fncs_configuration['values'].keys():
configuration_zpl += '\n {0}'.format(x)
configuration_zpl += '\n topic = {0}'.format(
fncs_configuration['values'][x]['topic'])
configuration_zpl += '\n default = {0}'.format(
fncs_configuration['values'][x]['default'])
configuration_zpl += '\n type = {0}'.format(
fncs_configuration['values'][x]['type'])
configuration_zpl += '\n list = {0}'.format(
fncs_configuration['values'][x]['list'])
try:
fncs.initialize(configuration_zpl)
if not fncs.is_initialized():
raise RuntimeError(
"fncs.initialize(configuration_zpl) failed!\nconfiguration_zpl = {}"
.format(configuration_zpl))
except Exception as e:
if fncs.is_initialized():
fncs.die()
raise
def run_simulation(self):
try:
current_time = 0
while current_time <= self.sim_length:
sim_message_topics = fncs.get_events()
if self.sim_id in sim_message_topics:
message = fncs.get_value(self.sim_id)
time_request = current_time + 1
if time_request > self.sim_length:
fncs.finalize()
break
time_approved = fncs.time_request(time_request)
if time_approved != time_request:
raise RuntimeError(
"The time approved from the fncs broker is not the time requested.\ntime_request = {}.\ntime_approved = {}"
.format(time_request, time_approved))
current_time += 1
except Exception as e:
if fncs.is_initialized():
fncs.die()
raise
def __register_federate(self):
self.__raise_if_not_installed()
cfg = """name = {0[name]}
time_delta = {0[time_delta]}
broker = {0[broker]}
""".format(dict(name=self._federate_name, broker=self._broker, time_delta=self._time_delta))
if self._registered_fncs_topics:
cfg += "values"
for k, v in self._registered_fncs_topics.items():
cfg += "\n\t{}\n\t\ttopic = {}\n".format(k, v['fncs_topic'])
if v.get("default"):
cfg += "\t\tdefault = {}\n".format(v.get('default'))
if v.get("data_type"):
cfg += "\t\ttype = {}\n".format(v.get('data_type'))
if v.get("list"):
cfg += "\t\tlist = true\n"
_log.debug(cfg)
cfg = cfg.replace("\t", " ")
fncs.initialize(cfg)
if not fncs.is_initialized():
raise RuntimeError("Intialization error for fncs.")
def _publish_to_fncs_bus(simulation_id, goss_message):
"""publish a message received from the GOSS bus to the FNCS bus.
Function arguments:
simulation_id -- Type: string. Description: The simulation id.
It must not be an empty string. Default: None.
goss_message -- Type: string. Description: The message from the GOSS bus
as a json string. It must not be an empty string. Default: None.
Function returns:
None.
Function exceptions:
RuntimeError()
ValueError()
"""
message_str = 'translating following message for fncs simulation '+simulation_id+' '+str(goss_message)
_send_simulation_status('RUNNING', message_str, 'DEBUG')
print(message_str)
if simulation_id == None or simulation_id == '' or type(simulation_id) != str:
raise ValueError(
'simulation_id must be a nonempty string.\n'
+ 'simulation_id = {0}'.format(simulation_id))
if goss_message == None or goss_message == '' or type(goss_message) != str:
raise ValueError(
'goss_message must be a nonempty string.\n'
+ 'goss_message = {0}'.format(goss_message))
if not fncs.is_initialized():
raise RuntimeError(
'Cannot publish message as there is no connection'
+ ' to the FNCS message bus.')
try:
test_goss_message_format = yaml.safe_load(goss_message)
if type(test_goss_message_format) != dict:
raise ValueError(
'goss_message is not a json formatted string.'
+ '\ngoss_message = {0}'.format(goss_message))
fncs_input_topic = '{0}/fncs_input'.format(simulation_id)
fncs_input_message = {"{}".format(simulation_id) : {}}
forward_differences_list = test_goss_message_format["message"]["forward_differences"]
for x in forward_differences_list:
object_name = (object_mrid_to_name.get(x.get("object"))).get("name")
object_phases = (object_mrid_to_name.get(x.get("object"))).get("phases")
object_total_phases = (object_mrid_to_name.get(x.get("object"))).get("total_phases")
object_type = (object_mrid_to_name.get(x.get("object"))).get("type")
object_name_prefix = ((difference_attribute_map.get(x.get("attribute"))).get(object_type)).get("prefix")
cim_attribute = x.get("attribute")
object_property_list = ((difference_attribute_map.get(x.get("attribute"))).get(object_type)).get("property")
phase_in_property = ((difference_attribute_map.get(x.get("attribute"))).get(object_type)).get("phase_sensitive",False)
if (object_name_prefix + object_name) not in fncs_input_message["{}".format(simulation_id)].keys():
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name] = {}
if cim_attribute == "RegulatingControl.mode":
val = x.get("value")
if val == 0:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0]] = "VOLT"
elif val == 2:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0]] = "VAR"
elif val == 3:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0]] = "CURRENT"
else:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0]] = "MANUAL"
_send_simulation_status("RUNNING", "Unsupported capacitor control mode requested. The only supported control modes for capacitors are voltage, VAr, volt/VAr, and current. Setting control mode to MANUAL.","WARN")
elif cim_attribute == "RegulatingControl.targetDeadband":
for y in difference_attribute_map[cim_attribute][object_type]["property"]:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][y] = "{}".format(x.get("value"))
elif cim_attribute == "RegulatingControl.targetValue":
for y in difference_attribute_map[cim_attribute][object_type]["property"]:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][y] = "{}".format(x.get("value"))
elif cim_attribute == "ShuntCompensator.aVRDelay":
for y in difference_attribute_map[cim_attribute][object_type]["property"]:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][y] = "{}".format(x.get("value"))
elif cim_attribute == "ShuntCompensator.sections":
if x.get("value") == 1:
val = "CLOSED"
else:
val = "OPEN"
for y in object_phases:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0].format(y)] = "{}".format(val)
elif cim_attribute == "Switch.open":
if x.get("value") == 1:
val = "OPEN"
else:
val = "CLOSED"
for y in object_total_phases:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0].format(y)] = "{}".format(val)
elif cim_attribute == "TapChanger.initialDelay":
for y in object_property_list:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][y] = "{}".format(x.get("value"))
elif cim_attribute == "TapChanger.step":
for y in object_phases:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0].format(y)] = "{}".format(x.get("value"))
elif cim_attribute == "TapChanger.lineDropCompensation":
if x.get("value") == 1:
val = "LINE_DROP_COMP"
else:
val = "MANUAL"
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0]] = "{}".format(val)
elif cim_attribute == "TapChanger.lineDropR":
for y in object_phases:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0].format(y)] = "{}".format(x.get("value"))
elif cim_attribute == "TapChanger.lineDropX":
for y in object_phases:
fncs_input_message["{}".format(simulation_id)][object_name_prefix + object_name][object_property_list[0].format(y)] = "{}".format(x.get("value"))
else:
_send_simulation_status("RUNNING", "Attribute, {}, is not a supported attribute in the simulator at this current time. ignoring difference.", "WARN")
goss_message_converted = json.dumps(fncs_input_message)
_send_simulation_status("RUNNING", "Sending the following message to the simulator. {}".format(goss_message_converted),"INFO")
if fncs.is_initialized():
fncs.publish_anon(fncs_input_topic, goss_message_converted)
except ValueError as ve:
raise ValueError(ve)
except Exception as ex:
_send_simulation_status("ERROR","An error occured while trying to translate the update message received","ERROR")
def _register_with_fncs_broker(broker_location='tcp://localhost:5570'):
"""Register with the fncs_broker and return.
Function arguments:
broker_location -- Type: string. Description: The ip location and port
for the fncs_broker. It must not be an empty string.
Default: 'tcp://localhost:5570'.
Function returns:
None.
Function exceptions:
RuntimeError()
ValueError()
"""
global is_initialized
global stop_simulation
configuration_zpl = ''
try:
message_str = 'Registering with FNCS broker '+str(simulation_id)+' and broker '+broker_location
('STARTED', message_str, 'INFO')
message_str = 'still connected to goss 1 '+str(goss_connection.is_connected())
_send_simulation_status('STARTED', message_str, 'INFO')
if simulation_id == None or simulation_id == '' or type(simulation_id) != str:
raise ValueError(
'simulation_id must be a nonempty string.\n'
+ 'simulation_id = {0}'.format(simulation_id))
if (broker_location == None or broker_location == ''
or type(broker_location) != str):
raise ValueError(
'broker_location must be a nonempty string.\n'
+ 'broker_location = {0}'.format(broker_location))
fncs_configuration = {
'name' : 'FNCS_GOSS_Bridge_' + simulation_id,
'time_delta' : '1s',
'broker' : broker_location,
'values' : {
simulation_id : {
'topic' : simulation_id + '/fncs_output',
'default' : '{}',
'type' : 'JSON',
'list' : 'false'
}
}
}
configuration_zpl = ('name = {0}\n'.format(fncs_configuration['name'])
+ 'time_delta = {0}\n'.format(fncs_configuration['time_delta'])
+ 'broker = {0}\nvalues'.format(fncs_configuration['broker']))
for x in fncs_configuration['values'].keys():
configuration_zpl += '\n {0}'.format(x)
configuration_zpl += '\n topic = {0}'.format(
fncs_configuration['values'][x]['topic'])
configuration_zpl += '\n default = {0}'.format(
fncs_configuration['values'][x]['default'])
configuration_zpl += '\n type = {0}'.format(
fncs_configuration['values'][x]['type'])
configuration_zpl += '\n list = {0}'.format(
fncs_configuration['values'][x]['list'])
fncs.initialize(configuration_zpl)
is_initialized = fncs.is_initialized()
if is_initialized:
message_str = 'Registered with fncs '+str(is_initialized)
_send_simulation_status('RUNNING', message_str, 'INFO')
except Exception as e:
message_str = 'Error while registering with fncs broker '+str(e)
_send_simulation_status('ERROR', message_str, 'ERROR')
stop_simulation = True
if fncs.is_initialized():
fncs.die()
if not fncs.is_initialized():
message_str = 'fncs.initialize(configuration_zpl) failed!\n' + 'configuration_zpl = {0}'.format(configuration_zpl)
_send_simulation_status('ERROR', message_str, 'ERROR')
stop_simulation = True
if fncs.is_initialized():
fncs.die()
raise RuntimeError(
'fncs.initialize(configuration_zpl) failed!\n'
+ 'configuration_zpl = {0}'.format(configuration_zpl))
def on_disconnected(self):
global stop_simulation
stop_simulation = True
if fncs.is_initialized():
fncs.die()
def initialize(self,
sim_start_time,
sim_length,
topic_mapping,
work_callback,
federate_name=None,
broker_location="tcp://localhost:5570",
time_delta="1s",
stop_agent_when_sim_complete=False):
""" Configure the agent to act as a federated connection to FNCS
sim_start_time - Wall clock time for the simulation start time (This is not used at present time other
than to be available)
sim_length - Time for the simulation to run. Should be formatted as <number><unit> i.e. 60s.
topic_mapping - Maps fncs topics onto volttron topics.
federate_name - MUST be unique to the broker. If None, then will be the
identity of the current agent process.
broker - tcp location of the fncs broker (defaults to tcp://localhost:5570)
time_delta - Minimum timestep supported for the federate.
stop_agent_when_sim_complete - Should we stop the agent when the simulation is completed.
:param sim_start_time:
:param sim_length:
:param topic_mapping:
:param work_callback:
:param federate_name:
:param broker_location:
:param time_delta:
:param poll_timeout:
:return:
"""
self.__raise_if_not_installed()
if fncs.is_initialized():
raise RuntimeError(
"Invalid state, fncs has alreayd been initialized")
if not topic_mapping:
raise ValueError(
"Must supply a topic mapping with topics to map onto.")
if not sim_start_time:
raise ValueError("sim_start_time must be specified.")
if not sim_length:
raise ValueError("sim_length must be specified.")
if not time_delta:
raise ValueError("time_delta must be specified.")
if not federate_name:
raise ValueError("federate_name must be specified.")
if not broker_location:
raise ValueError("broker_location must be specified.")
if not work_callback:
raise ValueError("work_callback must be specified.")
if not isinstance(sim_start_time, datetime):
raise ValueError("sim_start_time must be a datetime object.")
self._broker = broker_location
self._time_delta = time_delta
self._current_simulation_time = self._simulation_start_time = sim_start_time
self._simulation_delta = self.parse_time(time_delta)
self._simulation_length = self.parse_time(sim_length)
if federate_name:
self._federate_name = federate_name
self._work_callback = work_callback
for k, v in topic_mapping.items():
if not v.get('fncs_topic'):
raise ValueError(
"Invalid fncs_topic specified in key {}.".format(k))
entry = dict(fncs_topic=v.get('fncs_topic'))
if 'volttron_topic' in v:
entry['volttron_topic'] = v['volttron_topic']
self._registered_fncs_topics[k] = entry
self.__register_federate()
self._simulation_started = False
self._simulation_complete = False
self._stop_agent_when_sim_complete = stop_agent_when_sim_complete
def _raise_if_error(self, location):
if not fncs.is_initialized():
fncs.die()
raise RuntimeError("FNCS unexpected error: {}".format(location))
def initialize(self, sim_start_time, sim_length, topic_maping, work_callback, federate_name=None,
broker_location="tcp://localhost:5570", time_delta="1s", stop_agent_when_sim_complete=False):
""" Configure the agent to act as a federated connection to FNCS
sim_start_time - Wall clock time for the simulation start time (This is not used at present time other
than to be available)
sim_length - Time for the simulation to run. Should be formatted as <number><unit> i.e. 60s.
topic_mapping - Maps fncs topics onto volttron topics.
federate_name - MUST be unique to the broker. If None, then will be the
identity of the current agent process.
broker - tcp location of the fncs broker (defaults to tcp://localhost:5570)
time_delta - Minimum timestep supported for the federate.
stop_agent_when_sim_complete - Should we stop the agent when the simulation is completed.
:param sim_start_time:
:param sim_length:
:param topic_maping:
:param work_callback:
:param federate_name:
:param broker_location:
:param time_delta:
:param poll_timeout:
:return:
"""
self.__raise_if_not_installed()
if fncs.is_initialized():
raise RuntimeError("Invalid state, fncs has alreayd been initialized")
if not topic_maping:
raise ValueError("Must supply a topic mapping with topics to map onto.")
if not sim_start_time:
raise ValueError("sim_start_time must be specified.")
if not sim_length:
raise ValueError("sim_length must be specified.")
if not time_delta:
raise ValueError("time_delta must be specified.")
if not federate_name:
raise ValueError("federate_name must be specified.")
if not broker_location:
raise ValueError("broker_location must be specified.")
if not work_callback:
raise ValueError("work_callback must be specified.")
if not isinstance(sim_start_time, datetime):
raise ValueError("sim_start_time must be a datetime object.")
self._broker = broker_location
self._time_delta = time_delta
self._current_simulation_time = self._simulation_start_time = sim_start_time
self._simulation_delta = self.parse_time(time_delta)
self._simulation_length = self.parse_time(sim_length)
if federate_name:
self._federate_name = federate_name
self._work_callback = work_callback
for k, v in topic_maping.items():
if not v.get('fncs_topic'):
raise ValueError("Invalid fncs_topic specified in key {}.".format(k))
entry = dict(fncs_topic=v.get('fncs_topic'))
if 'volttron_topic' in v.keys():
entry['volttron_topic'] = v['volttron_topic']
self._registered_fncs_topics[k] = entry
self.__register_federate()
self._simulation_started = False
self._simulation_complete = False
self._stop_agent_when_sim_complete = stop_agent_when_sim_complete
def _raise_if_error(self, location):
if not fncs.is_initialized():
fncs.die()
raise RuntimeError("FNCS unexpected error: {}".format(location))