def main():
desc = 'Simple visualization for mosaik simulations'
extra_opts = [
'-s HOST:PORT, --serve=HOST:PORT ',
(' Host and port for the webserver '
'[default: 127.0.0.1:8000]'),
]
mosaik_api.start_simulation(MosaikWeb(), desc, extra_opts)
def main():
return mosaik_api.start_simulation(MonitoringRTU())
def main():
return mosaik_api.start_simulation(AgentStorageControl())
def main():
return mosaik_api.start_simulation(ExampleSim())
def main():
return mosaik_api.start_simulation(Controller())
def main():
return mosaik_api.start_simulation(PowerFactoryRMSSimulator())
def main():
mosaik_api.start_simulation(MyGrid(), 'The mosaik-MyGrid adapter')
self.eid = None
self.data = collections.defaultdict(lambda:
collections.defaultdict(list))
self.step_size = None
def init(self, sid, step_size):
self.step_size = step_size
return self.meta
def create(self, num, model):
if num > 1 or self.eid is not None:
raise RuntimeError('Can only create one instance of Monitor.')
self.eid = 'Monitor'
return [{'eid': self.eid, 'type': model}]
def step(self, time, inputs):
data = inputs[self.eid]
for attr, values in data.items():
for src, value in values.items():
self.data[src][attr].append(value)
return time + self.step_size
def finalize(self):
pprint.pprint(self.data)
if __name__ == '__main__':
mosaik_api.start_simulation(Collector())
def main():
return mosaik_api.start_simulation(CSV(), 'controller-csv simulator')
def main():
return mosaik_api.start_simulation(ProsumerSim())
def main():
return mosaik_api.start_simulation(HouseholdSim(), 'Household simulation')
def main():
return mosaik_api.start_simulation(UtilitySim())
def main():
return mosaik_api.start_simulation(ExampleDERSim(), 'Example DER simulator')
def main():
return mosaik_api.start_simulation(ChpSim(), 'CHP simulator')
def main():
mosaik_api.start_simulation(PyPower(), 'The mosaik-PYPOWER adapter')
def main():
return mosaik_api.start_simulation(PowerFactoryLDFSimulator())
def main():
"""Run our simulator and expose the "WecsSim"."""
return mosaik_api.start_simulation(WecsSim(), 'WECS simulator')
else: # Controller is not responsive (dead time).
if time >= self.wakeup_time[eid]:
self.wakeup_time[eid] = None
self.is_responsive[eid] = True
edata['tap_position'] = self.tap_position[eid]
if self.verbose:
print("Actuate tap position {} at time {}".format(
tap_setpoint, time))
return time + 1
def get_data(self, outputs):
data = {}
for eid, edata in self.data.items():
requests = outputs[eid]
mydata = {}
for attr in requests:
try:
mydata[attr] = edata[
attr] if self.is_responsive[eid] is True else None
except KeyError:
raise RuntimeError(
"Tap actuator has no attribute {0}".format(attr))
data[eid] = mydata
return data
if __name__ == '__main__':
mosaik_api.start_simulation(TapActuator())
def main():
desc = "Running the influxDB Connector as Server"
mosaik_api.start_simulation(Simulator(), desc)
self.translation_table.setdefault('parameter', {})
self.translation_table.setdefault('input', {})
self.translation_table.setdefault('output', {})
def set_values(self, eid, val_dict, var_type):
'''Helper function to set input variable and parameter values to a FMU instance'''
for alt_name, val in val_dict.items():
name = self.translation_table[var_type][alt_name]
#print( 'set_values func = {}, name = {}, val = {}'.format( 'set' + self.var_table[var_type][name] + 'Value', name, val ) )
# Obtain setter function according to specified var type (Real, Integer, etc.):
set_func = getattr(
self._entities[eid],
'set' + self.var_table[var_type][name] + 'Value')
set_stat = set_func(name, val)
assert set_stat == fmipp.fmiOK
def get_value(self, eid, alt_attr):
'''Helper function to get output variable values from a FMU instance.'''
attr = self.translation_table['output'][alt_attr]
# Obtain getter function according to specified var type (Real, Integer, etc.):
get_func = getattr(self._entities[eid],
'get' + self.var_table['output'][attr] + 'Value')
val = get_func(attr)
#if val is not 0: print( 'get_value func = {}, attr = {}, val = {}'.format( 'get' + self.var_table['output'][attr] + 'Value', attr, val ) )
return val
if __name__ == '__main__':
mosaik_api.start_simulation(TC3PowerSystem())
self.var_table.setdefault('parameter', {})
self.var_table.setdefault('input', {})
self.var_table.setdefault('output', {})
self.translation_table.setdefault('parameter', {})
self.translation_table.setdefault('input', {})
self.translation_table.setdefault('output', {})
def set_values(self, eid, val_dict, var_type):
'''Helper function to set input variable and parameter values to a FMU instance'''
for alt_name, val in val_dict.items():
name = self.translation_table[var_type][alt_name]
# Obtain setter function according to specified var type (Real, Integer, etc.):
set_func = getattr(self._entities[eid],
'set' + self.var_table[var_type][name])
set_func([name], [val])
def get_value(self, eid, alt_attr):
'''Helper function to get output variable values from a FMU instance.'''
attr = self.translation_table['output'][alt_attr]
# Obtain getter function according to specified var type (Real, Integer, etc.):
get_func = getattr(self._entities[eid],
'get' + self.var_table['output'][attr])
val = get_func([attr])[0]
#if val is not 0: print( 'TC3CommNetwork::get_value attr = {}, val = {}'.format( attr, val ) )
return val
if __name__ == '__main__':
mosaik_api.start_simulation(TC3CommNetwork())
def main():
return mosaik_api.start_simulation(PeriodicSender())
def main():
return mosaik_api.start_simulation(BatterySim(), 'Battery Simulation')
def main(self):
return mosaik_api.start_simulation(Attack(), 'example attack')
self.var_table.setdefault('input', {})
self.var_table.setdefault('output', {})
self.translation_table.setdefault('parameter', {})
self.translation_table.setdefault('input', {})
self.translation_table.setdefault('output', {})
def set_values(self, eid, val_dict, var_type):
'''Helper function to set input variable and parameter values to a FMU instance'''
for alt_name, val in val_dict.items():
name = self.translation_table[var_type][alt_name]
# Obtain setter function according to specified var type (Real, Integer, etc.):
set_func = getattr(self._entities[eid], 'set' + self.var_table[var_type][name] + 'Value')
set_stat = set_func(name, val)
assert set_stat == fmipp.fmiOK
def get_value(self, eid, alt_attr):
'''Helper function to get output variable values from a FMU instance.'''
attr = self.translation_table['output'][alt_attr]
# Obtain getter function according to specified var type (Real, Integer, etc.):
get_func = getattr(self._entities[eid], 'get' + self.var_table['output'][attr] + 'Value')
val = get_func(attr)
#if val is not 0: print( 'get_value attr = {}, val = {}'.format( attr, val ) )
return val
if __name__ == '__main__':
mosaik_api.start_simulation(TC3Controller())
def init(self, sid, step_size):
self.step_size = step_size
return self.meta
def create(self, num, model):
if num > 1 or self.eid is not None:
raise RuntimeError('Can only create one instance of Monitor.')
self.eid = 'Monitor'
return [{'eid': self.eid, 'type': model}]
def step(self, time, inputs):
data = inputs[self.eid]
for attr, values in data.items():
for src, value in values.items():
self.data[src][attr].append(value)
return time + self.step_size
def finalize(self):
print('Collected data:')
for sim, sim_data in sorted(self.data.items()):
print('- %s:' % sim)
for attr, values in sorted(sim_data.items()):
print(' - %s: %s' % (attr, values))
if __name__ == '__main__':
mosaik_api.start_simulation(Collector())
"""
This function is used to add an entry in the self.HouseDict dictionary.
Instantiates a new Protocol object for each house.
"""
if key in self.HouseDict:
return
else:
protocol = self.protocol.Protocol(self.N, self.eid, False, 0,
self.qkd)
self.HouseDict[key] = {
"commLayer": comLayer(protocol,
protocol.__get_states_mapping__()),
"protocol": protocol
}
def get_data(self, outputs):
self.ccresponse = []
for key, val in self.HouseDict.items():
self.ccresponse.append(
json.dumps(self.HouseDict[key]["protocol"].outputs))
data = {}
for eid, attrs in outputs.items():
data[eid] = {}
for attr in attrs:
data[eid][attr] = self.ccresponse
return data
if __name__ == '__main__':
mosaik_api.start_simulation(CC())
