def __init__(self, friendly_name, in_file_name, out_file_name, read_params,
write_params):
"""
__init__(self, friendly_name, infile, outfile, read_params, write_params)
Initialize the PQFileReader Actor with the read_params and write_params dependency list.
Data are read from infile, and get to the simulation on getValue function call.
:param friendly_name: Element name id
:param in_file_name: csv file to read value from (P,Q)
:param out_file_name: log the data out
:param read_params: Read param to register on
:param write_params: Write param to register on
"""
Actor.__init__(self)
AbstractSimulationElement.__init__(self, friendly_name)
self.read_params = read_params
self.write_params = write_params
self._in_opcode = {}
self._in_file = TimeSeriesObject(CSVReader(in_file_name))
# temp out storage for logging to file
self._out_log = {}
self._init_out_file = False
self._out_file = open(out_file_name, 'w')
def test_warning_no_header(self):
time_series = TimeSeriesObject(CSVReader('./test/data/datatest_no_header.csv'))
warnings.simplefilter('error', SyntaxWarning)
with self.assertRaises(SyntaxWarning):
time_series.load(time_key='hero',
time_converter=lambda t: t*2*units.minute)
warnings.simplefilter('default', SyntaxWarning)
def test_already_present_key(self):
time_series = TimeSeriesObject(CSVReader('./test/data/datatest_with_no_time_header.csv'))
time_series.load(time_key='counter',
time_converter=lambda t: t*2*units.minute)
self.assertRaises(AttributeError, time_series.map_attribute,
'counter', 'counter')
def test_no_time_header(self):
time_series = TimeSeriesObject(CSVReader('./test/data/datatest_with_no_time_header.csv'))
time_series.load(time_key='counter',
time_converter=lambda t: t*2*units.minute)
time_series.set_time(4.0*units.minute)
self.assertEqual(time_series.counter, 4.0*units.minute)
self.assertEqual(time_series.temperature, 18.0)
self.assertEqual(time_series.humidity, 0.1)
def __init__(self, friendly_name, in_file_name, out_file_name, read_params, write_params):
"""
__init__(self, friendly_name, infile, outfile, read_params, write_params)
Initialize the PQFileReader Actor with the read_params and write_params dependency list.
Data are read from infile, and get to the simulation on getValue function call.
:param friendly_name: Element name id
:param in_file_name: csv file to read value from (P,Q)
:param out_file_name: log the data out
:param read_params: Read param to register on
:param write_params: Write param to register on
"""
Actor.__init__(self)
AbstractSimulationElement.__init__(self, friendly_name)
self.read_params = read_params
self.write_params = write_params
self._in_opcode = {}
self._in_file = TimeSeriesObject(CSVReader(in_file_name))
# temp out storage for logging to file
self._out_log = {}
self._init_out_file = False
self._out_file = open(out_file_name, 'w')
def test_change_time_key(self):
time_series = TimeSeriesObject(CSVReader('./test/data/datatest_with_no_time_header.csv'))
time_series.load(time_key='counter',
time_converter=lambda t: t*2*units.minute)
time_series.map_attribute('counter', 'minutes', is_time_key=True)
time_series.set_time(4.0*units.minute)
self.assertEqual(time_series.minutes, 4.0*units.minute)
self.assertEqual(time_series.temperature, 18.0)
self.assertEqual(time_series.humidity, 0.1)
class MyObject(AbstractSimulationElement):
def __init__(self, friendly_name, reader):
super(MyObject, self).__init__(friendly_name)
self._time_series = TimeSeriesObject(reader)
self._time_series.load(time_converter=lambda t: t * units.day)
def __getattr__(self, item):
return getattr(self._time_series, item)
def reset(self):
pass
def calculate(self, time, delta_time):
pass
def update(self, time, delta_time):
self._time_series.set_time(time)
def convert(self, item, converter):
return self._time_series.convert(item, converter)
class MyObject(AbstractSimulationElement):
def __init__(self, friendly_name, reader):
super(MyObject, self).__init__(friendly_name)
self._time_series = TimeSeriesObject(reader)
self._time_series.load(time_converter=lambda t: t*units.day)
def __getattr__(self, item):
return getattr(self._time_series, item)
def reset(self):
pass
def calculate(self, time, delta_time):
pass
def update(self, time, delta_time):
self._time_series.set_time(time)
def convert(self, item, converter):
return self._time_series.convert(item, converter)
def test_convert_load(self):
time_series = TimeSeriesObject(CSVReader('./test/data/datatest_with_header.csv'))
time_series.load(time_converter=lambda t: t*2*units.minute)
time_series.set_time(4.0*units.minute)
self.assertEqual(time_series.time, 4.0*units.minute)
self.assertEqual(time_series.temperature, 18.0)
self.assertEqual(time_series.humidity, 0.1)
time_series.set_time(3.2*units.minute)
self.assertEqual(time_series.time, 4.0*units.minute)
self.assertEqual(time_series.temperature, 18.0)
self.assertEqual(time_series.humidity, 0.1)
time_series.set_time(2.1*units.minute)
self.assertEqual(time_series.time, 2.0*units.minute)
self.assertEqual(time_series.temperature, 20.0)
self.assertEqual(time_series.humidity, 0.25)
time_series.set_time(0.0*units.minute)
self.assertEqual(time_series.time, 0.0*units.minute)
self.assertEqual(time_series.temperature, 20.0)
self.assertEqual(time_series.humidity, 0.2)
def test_default_load(self):
time_series = TimeSeriesObject(CSVReader('./test/data/large_datatest_with_header.csv'))
time_series.load()
time_series.set_time(2*units.second)
self.assertEqual(time_series.time, 2*units.second)
self.assertEqual(time_series.temperature, 2.3)
self.assertEqual(time_series.solar_radiation, 0.0)
time_series.set_time(12.2*units.second)
self.assertEqual(time_series.time, 12.0*units.second)
self.assertEqual(time_series.temperature, 4.8)
self.assertEqual(time_series.solar_radiation, 152.4)
time_series.set_time(1551.0*units.second)
self.assertEqual(time_series.time, 1551.0*units.second)
self.assertEqual(time_series.temperature, 14.7)
self.assertEqual(time_series.solar_radiation, 175.8)
time_series.set_time(0.0*units.second)
self.assertEqual(time_series.time, 0.0*units.second)
self.assertEqual(time_series.temperature, 2.2)
self.assertEqual(time_series.solar_radiation, 0.0)
time_series.set_time(8759*units.second)
self.assertEqual(time_series.time, 8759.0*units.second)
self.assertEqual(time_series.temperature, 0.3)
self.assertEqual(time_series.solar_radiation, 0.0)
def __init__(self, friendly_name, reader):
super(MyObject, self).__init__(friendly_name)
self._time_series = TimeSeriesObject(reader)
self._time_series.load(time_converter=lambda t: t*units.day)
from gridsim.unit import units
from gridsim.iodata.input import CSVReader
from gridsim.timeseries import TimeSeriesObject
# Load time series into a new object.
obj = TimeSeriesObject(CSVReader('./data/example.csv'))
obj.load()
# Print value at start time.
print obj.temperature
# Proceed 120 and output the temperature at that moment.
obj.set_time(120 * units.second)
print obj.temperature
def __init__(self, friendly_name, reader):
super(MyObject, self).__init__(friendly_name)
self._time_series = TimeSeriesObject(reader)
self._time_series.load(time_converter=lambda t: t * units.day)
from gridsim.unit import units
from gridsim.iodata.input import CSVReader
from gridsim.timeseries import TimeSeriesObject
# Load time series into a new object.
obj = TimeSeriesObject(CSVReader('./data/example.csv'))
obj.load()
# Print value at start time.
print obj.temperature
# Proceed 120 and output the temperature at that moment.
obj.set_time(120*units.second)
print obj.temperature
class PQFileReader(Actor, AbstractSimulationElement,
CyberPhysicalModuleListener):
@accepts(((1, 2, 3), str), ((4, 5), list))
def __init__(self, friendly_name, in_file_name, out_file_name, read_params,
write_params):
"""
__init__(self, friendly_name, infile, outfile, read_params, write_params)
Initialize the PQFileReader Actor with the read_params and write_params dependency list.
Data are read from infile, and get to the simulation on getValue function call.
:param friendly_name: Element name id
:param in_file_name: csv file to read value from (P,Q)
:param out_file_name: log the data out
:param read_params: Read param to register on
:param write_params: Write param to register on
"""
Actor.__init__(self)
AbstractSimulationElement.__init__(self, friendly_name)
self.read_params = read_params
self.write_params = write_params
self._in_opcode = {}
self._in_file = TimeSeriesObject(CSVReader(in_file_name))
# temp out storage for logging to file
self._out_log = {}
self._init_out_file = False
self._out_file = open(out_file_name, 'w')
@accepts((1, dict))
def initFile(self, opcode):
"""
initFile(self)
Initialize the File to read data from,
and prepare the output file.
"""
for k, t in opcode.items():
self._in_opcode[t] = k
self._in_file.load()
def reset(self):
pass
def update(self, time, delta_time):
self._in_file.set_time(time)
def calculate(self, time, delta_time):
pass
def cyberphysical_read_end(self):
# push all the data after the read is finished in the log file
self._out_log = collections.OrderedDict(sorted(self._out_log.items()))
if not self._init_out_file:
self._init_out_file = True
title = ','.join(
i.replace('ParamType.', '') for i in self._out_log.keys())
self._out_file.write(title + '\n')
data = ','.join(str(i) for i in self._out_log.values())
self._out_file.write(data + '\n')
self._out_file.flush()
@accepts((2, (int, float)))
def notify_read_param(self, read_param, data):
# save data to temp list
self._out_log[str(read_param)] = data
@returns((int, float))
def get_value(self, write_param):
# get the new data from the file based on write_param
if write_param in self._in_opcode.keys():
val = getattr(self._in_file, str(self._in_opcode[write_param]))
return val
return 0
def cyberphysical_module_end(self):
print 'end simulation from PQFileReader'
if not self._out_file is None:
self._out_file.close()
class PQFileReader(Actor, AbstractSimulationElement, CyberPhysicalModuleListener):
@accepts(((1, 2, 3), str), ((4, 5), list))
def __init__(self, friendly_name, in_file_name, out_file_name, read_params, write_params):
"""
__init__(self, friendly_name, infile, outfile, read_params, write_params)
Initialize the PQFileReader Actor with the read_params and write_params dependency list.
Data are read from infile, and get to the simulation on getValue function call.
:param friendly_name: Element name id
:param in_file_name: csv file to read value from (P,Q)
:param out_file_name: log the data out
:param read_params: Read param to register on
:param write_params: Write param to register on
"""
Actor.__init__(self)
AbstractSimulationElement.__init__(self, friendly_name)
self.read_params = read_params
self.write_params = write_params
self._in_opcode = {}
self._in_file = TimeSeriesObject(CSVReader(in_file_name))
# temp out storage for logging to file
self._out_log = {}
self._init_out_file = False
self._out_file = open(out_file_name, 'w')
@accepts((1, dict))
def initFile(self, opcode):
"""
initFile(self)
Initialize the File to read data from,
and prepare the output file.
"""
for k, t in opcode.items():
self._in_opcode[t] = k
self._in_file.load()
def reset(self):
pass
def update(self, time, delta_time):
self._in_file.set_time(time)
def calculate(self, time, delta_time):
pass
def cyberphysical_read_end(self):
# push all the data after the read is finished in the log file
self._out_log = collections.OrderedDict(sorted(self._out_log.items()))
if not self._init_out_file:
self._init_out_file = True
title = ','.join(i.replace('ParamType.', '') for i in self._out_log.keys())
self._out_file.write(title + '\n')
data = ','.join(str(i) for i in self._out_log.values())
self._out_file.write(data + '\n')
self._out_file.flush()
@accepts((2, (int, float)))
def notify_read_param(self, read_param, data):
# save data to temp list
self._out_log[str(read_param)] = data
@returns((int, float))
def get_value(self, write_param):
# get the new data from the file based on write_param
if write_param in self._in_opcode.keys():
val = getattr(self._in_file, str(self._in_opcode[write_param]))
return val
return 0
def cyberphysical_module_end(self):
print 'end simulation from PQFileReader'
if not self._out_file is None:
self._out_file.close()