def update(self, playboard):
if not self.staff_randomized:
for staff in playboard.model.staff:
x, y = playboard.get_random_open_tile()
staff.x = x * 32 + 16
staff.y = y * 32 + 16
self.staff_randomized = True
event = self.get_events_for_frame()
if event != None:
type = event[0]
if type == 'device':
device_type = event[2]
ailment = event[3]
device = Device(playboard, self.counter, device_type, 200, 10, ailment)
self.devices.append(device)
self.active_devices.append(device)
new_active_devices = []
for device in self.active_devices:
device.update()
if device.state == 'new':
playboard.animations.append({
'type': 'device',
'ttl': 10,
'mx': device.x,
'my': device.y,
'x': device.x,
'y': device.y,
'device': device.device_type,
'overlay': 'check',
'vx': 0,
'vy': -3
})
elif device.state == 'dead' and device.replaced:
playboard.animations.append({
'type': 'device',
'ttl': 10,
'mx': device.x,
'my': device.y,
'x': device.x,
'y': device.y,
'device': device.device_type,
'overlay': 'dead',
'vx': 0,
'vy': -3
})
else:
new_active_devices.append(device)
self.active_devices = new_active_devices
self.counter += 1
def testGetDistanceBetweenDevices(self):
section = LinacAbstractSection("test", None, None, 600)
self.assertEqual(section.numberOfDevices(), 0)
self.assertEqual(section.getDistanceBetweenDevices(), 600)
dev1 = Device("dev1", None, None)
section.addDevice(dev1)
self.assertEqual(section.getDistanceBetweenDevices(), 300)
dev2 = Device("dev2", None, None)
section.addDevice(dev2)
self.assertEqual(section.getDistanceBetweenDevices(), 200)
def testAddDevice(self):
device = Device("abcde", None, None)
section = Section("test", "grey")
self.assertEqual(section.numberOfDevices(), 0)
section.addDevice(device)
self.assertEqual(section.numberOfDevices(), 1)
self.assertEqual(section.devices[0], device)
self.assertEqual(device.numberInSection, 0)
otherDevice = Device("other", None, None)
section.addDevice(otherDevice)
self.assertEqual(otherDevice.numberInSection, 1)
def testSubsystemName(self):
device = Device("I-TL/VAC/I-TL-CAB02-VAC-IPCU1", None, None)
self.assertEqual(device.subsystemName, "VAC")
device = Device("I-S00/MAG/I-S00-MAG-COBX2", None, None)
self.assertEqual(device.subsystemName, "MAG")
device = Device("I-K01/RF/I-K01CAB03-RF-LLRFL1", None, None)
self.assertEqual(device.subsystemName, "RF")
device = Device("I-S00/DIA/I-S00-DIA-SCRN1", None, None)
self.assertEqual(device.subsystemName, "DIA")
def testGetDevice(self):
dev1 = Device("foo", None, None)
dev2 = Device("bar", None, None)
section = Section("test", "grey")
self.assertEqual(section.numberOfDevices(), 0)
section.addDevice(dev1)
section.addDevice(dev2)
self.assertEqual(section.numberOfDevices(), 2)
self.assertEqual(section.getDevice(0), dev1)
self.assertNotEqual(section.getDevice(0), dev2)
self.assertEqual(section.getDevice(1), dev2)
self.assertEqual(section.getDevice(3), None)
def testAssignDevicesBeforeDrawing(self):
section = self.linac.addSection("I-K01", None, 200)
subsection = section.addSubsection("I-K01A", None, 50)
firstDevice = Device("I-K01/ab/cd", None, [12, 20])
secondDevice = Device("I-K01A/ef/gh", None, [5, 20])
thirdDevice = Device("I-K01A/ij/kl", None, [15, 20])
self.linac.addDevice(firstDevice)
self.linac.addDevice(secondDevice)
self.linac.addDevice(thirdDevice)
self.assertEqual(firstDevice.section, section)
self.linac.assignDevicesBeforeDrawing()
self.assertEqual(firstDevice.section, subsection)
def testAddDevice(self):
device = Device("ABC/MAG/device123", None, None)
anotherDevice = Device("ABC/VAC/dev7", None, None)
self.linac.addSection("ABC")
section = self.linac.getSection("ABC")
self.assertEqual(section.numberOfDevices(), 0)
self.assertEqual(section.getDevice(0), None)
self.linac.addDevice(device)
self.assertEqual(section.getDevice(0), device)
self.assertEqual(section.getDevice(1), None)
self.linac.addDevice(anotherDevice)
self.assertEqual(section.getDevice(1), anotherDevice)
self.assertEqual(section.numberOfDevices(), 2)
def testAssigningSvgCoordinate(self):
device = Device("abc/testDevice", None, None)
self.assertEqual(device.svgCoordinateX, None)
linac = Linac()
linac.addSection("abc")
linac.addDevice(device)
device.assignSvgCoordinatesForLinacDevice()
testSection = linac.getSection("abc")
sectionStartCoordinate = testSection.startCoordinate
distanceBetweenDevices = testSection.getDistanceBetweenDevices()
self.assertEqual(device.svgCoordinateX,
sectionStartCoordinate + distanceBetweenDevices)
def testSortDevices(self):
firstDevice = Device("First", None, [184, 99])
secondDevice = Device("Second", None, [964, 80])
section = Section("test", None)
section.addDevice(secondDevice)
section.addDevice(firstDevice)
self.assertEqual(section.getDevice(0), secondDevice)
self.assertEqual(section.getDevice(0).numberInSection, 0)
self.assertEqual(section.getDevice(1).numberInSection, 1)
section.sortDevices()
self.assertEqual(section.getDevice(0), firstDevice)
self.assertEqual(section.getDevice(0).numberInSection, 0)
self.assertEqual(section.getDevice(1).numberInSection, 1)
def testConfiguration(self):
coord = (12, 13.901)
icon = Icon("test/path")
device = Device("name", icon, coord)
self.assertEqual(device.icon, icon)
self.assertEqual(device.realCoordinates, coord)
self.assertEqual(device.name, "name")
def testGetAllDevicesSorted(self):
section = self.linac.addSection("A", None, 100)
subsection = section.addSubsection("A-1", None, 20)
firstDevice = Device("first", None, [301, 222])
secondDevice = Device("second", None, [154, 222])
thirdDevice = Device("third", None, [101, 222])
fourthDevice = Device("fourth", None, [55, 30])
subsection.addDevice(firstDevice)
subsection.addDevice(secondDevice)
section.addDevice(thirdDevice)
section.addDevice(fourthDevice)
devices = self.linac.getAllDevicesSorted()
self.assertEqual(
devices, [fourthDevice, thirdDevice, secondDevice, firstDevice])
self.assertEqual(devices[0].numberInSection, 0)
self.assertEqual(devices[2].numberInSection, 0)
self.assertEqual(devices[3].numberInSection, 1)
def testSortDevicesRecursively(self):
section = LinacSection("A", None, 100)
subsection = section.addSubsection("A01", None, 50)
firstDevice = Device("first", None, [301,222])
secondDevice = Device("second", None, [154,222])
thirdDevice = Device("third", None, [101,222])
fourthDevice = Device("fourth", None, [55, 30])
subsection.addDevice(firstDevice)
subsection.addDevice(secondDevice)
section.addDevice(thirdDevice)
section.addDevice(fourthDevice)
devices = section.getAllDevices()
self.assertEqual(devices[0], thirdDevice)
self.assertEqual(devices[2], firstDevice)
section.sortDevicesRecursively()
devices = section.getAllDevices()
self.assertEqual(devices[0], fourthDevice)
self.assertEqual(devices[2], secondDevice)
def __init__(self, config_file="config.yaml", device_init=True):
self.FILE_FOLDER = "./files/"
self.SRC_FOLDER = "./src/"
with open(self.SRC_FOLDER+config_file, "r") as fp:
self.config = yaml.safe_load(fp)
self.test_config = self.config["test"]
self.test_file = self.test_config["test_script"]
self.input_points_header = self.test_config.get("input_points_header", "Simulation (controller) Inputs")
self.conditions_header = self.test_config.get("conditions_header", "Result Time")
self.output_points_header = self.test_config.get("output_points_header", "Expected Controller BACnet Outputs")
if device_init:
self.controller = Device(device_config=self.config["device"])
self.map_file = self.test_config["point_map"]
self.init_device(mapping_file=self.map_file)
self.init_test_sequence(filename=self.test_file, ip_header=self.input_points_header, cond_header=self.conditions_header, op_header=self.output_points_header, point_prop=self.point_properties)
class TestDevice(unittest.TestCase):
def setUp(self):
self.device = Device()
self.device2 = Device("Jumpy Whale")
def test_check_initial(self):
for attrib in [
"device_name", "device_uuid", "polling_rate", "sensor_manager"
]:
self.assertTrue(hasattr(self.device, attrib))
def test_polling_bad_Set(self):
with self.assertRaises(Exception):
self.device.polling_rate = "25"
def test_polling_good_Set(self):
new_value = 10
self.device.polling_rate = new_value
self.assertTrue(self.device.polling_rate == new_value)
def test_name_bad_Set(self):
with self.assertRaises(Exception):
self.device.device_name = "super cool name"
def test_name_good_Set(self):
new_name = "sleepy dog"
self.device.device_name = new_name
self.assertTrue(self.device.device_name == new_name)
def test_uuid_bad_Set(self):
with self.assertRaises(Exception):
new_uuid = 1234
self.device.device_uuid = new_uuid
def test_uuid_good_Set(self):
new_val = uuid.uuid4()
self.device.device_uuid = new_val
self.assertTrue(self.device.device_uuid == new_val)
def test_payload_contents(self):
sample_payload = self.device.generate_payload()
for attrib in [
"Device_Name",
"Device_UUID",
"GPS",
"ambient_temperature",
"internal_temperature",
"Latch",
"timestamp",
]:
self.assertTrue(attrib in sample_payload)
def testDrawDevice(self):
icon = Icon("symbol-quadrupole.svg")
device = Device("I-K01/VAC/I-K01CAB05-VAC-IPCU1", icon, (113, 122))
linac = Linac()
linac.addSection("I-K01")
linac.addDevice(device)
blankSVGpath = 'blank.svg'
svgTree = etree.parse(blankSVGpath)
svgRoot = svgTree.getroot()
svgFile = svg.SVG()
svgFile.setSvg(svgRoot)
device.updateSvg()
vacNode = svgFile.getSubsystemZoomNode("VAC")
deviceNode = svgFile.getElementById("ik01vacik01cab05vacipcu1",
vacNode)
self.assertEqual(
deviceNode.attrib["{http://www.w3.org/1999/xlink}href"],
"#symbol-quadrupole")
descriptionNode = svgFile.getElementById(
"ik01vacik01cab05vacipcu1Desc", deviceNode)
self.assertEqual(descriptionNode.text,
"device=I-K01/VAC/I-K01CAB05-VAC-IPCU1")
def testGetAllDevices(self):
section = LinacSection("I-K00", None, 0)
firstDevice = Device("test1", None, None)
secondDevice = Device("test2", None, None)
thirdDevice = Device("test3", None, None)
fourthDevice = Device("test4", None, None)
section.addSubsection("I-K01A", None, 100)
section.addSubsection("I-K01B", None, 100)
firstSubsection = section.getSubsection("I-K01A")
secondSubsection = section.getSubsection("I-K01B")
firstSubsection.addDevice(firstDevice)
section.addDevice(secondDevice)
secondSubsection.addDevice(thirdDevice)
firstSubsection.addDevice(fourthDevice)
allDevices = section.getAllDevices()
self.assertTrue(firstDevice in allDevices)
self.assertTrue(secondDevice in allDevices)
self.assertTrue(thirdDevice in allDevices)
self.assertTrue(fourthDevice in allDevices)
self.assertEqual(len(allDevices), 4)
def testCheckingConditions(self):
deviceWithoutIcon = Device("A/B/C", None, None)
deviceWithoutIcon.section = True
with self.assertRaises(Exception):
deviceWithoutIcon.checkNecessaryConditions()
deviceWithoutSection = Device("D/E/F", Icon("test"), None)
with self.assertRaises(Exception):
deviceWithoutSection.checkNecessaryConditions()
deviceWithWrongSubsystem = Device("GHI", Icon("test"), None)
deviceWithWrongSubsystem.section = True
with self.assertRaises(Exception):
deviceWithWrongSubsystem.checkNecessaryConditions()
def add_new_device(self, dev):
d = Device(dev)
self.data_list.append(d)
print "Device added: %s (%s)" % (d.device_name(), d.device_type())
self.dataChanged.emit(self.index(len(self.data_list) - 1, 0), self.index(len(self.data_list) - 1, 1))
class Test:
def __init__(self, config_file="config.yaml", device_init=True):
self.FILE_FOLDER = "./files/"
self.SRC_FOLDER = "./src/"
with open(self.SRC_FOLDER+config_file, "r") as fp:
self.config = yaml.safe_load(fp)
self.test_config = self.config["test"]
self.test_file = self.test_config["test_script"]
self.input_points_header = self.test_config.get("input_points_header", "Simulation (controller) Inputs")
self.conditions_header = self.test_config.get("conditions_header", "Result Time")
self.output_points_header = self.test_config.get("output_points_header", "Expected Controller BACnet Outputs")
if device_init:
self.controller = Device(device_config=self.config["device"])
self.map_file = self.test_config["point_map"]
self.init_device(mapping_file=self.map_file)
self.init_test_sequence(filename=self.test_file, ip_header=self.input_points_header, cond_header=self.conditions_header, op_header=self.output_points_header, point_prop=self.point_properties)
def init_device(self, mapping_file):
with open(self.FILE_FOLDER+mapping_file, "r") as fp:
mapping_dict = json.load(fp)
self.mapping = pd.DataFrame(data=list(mapping_dict.keys()), index=list(mapping_dict.values()), columns=['name_in_test'])
self.mapping.index.name = 'bacnet_name'
self.point_properties = self.controller.get_point_properties()
self.point_properties = pd.merge(left=self.point_properties, right=self.mapping, how='inner', left_index=True, right_index=True)
object_list = self.point_properties.apply(lambda x: (x['type'], x['address']), axis=1).values.tolist()
self.controller.reset_device(object_list = object_list)
self.points = {}
def init_test_sequence(self, filename, ip_header, cond_header, op_header, point_prop):
self.test_df = pd.read_excel(self.FILE_FOLDER+filename, index_col=0, header=None)
self.ip = self.format_excel_df(df=self.test_df.loc[ip_header:cond_header].iloc[1:-1], point_prop=point_prop)
self.cond = self.format_excel_df(df=self.test_df.loc[cond_header:op_header].iloc[1:-1], is_cond_df=True, point_prop=point_prop)
self.op = self.format_excel_df(df=self.test_df.loc[op_header:].iloc[1:], point_prop=point_prop)
self.acceptable_op_bounds = self.op.loc["acceptable_bounds"]
self.current_step = None
self.step_outputs = {}
self.ramp_step = False
self.ramp_variables = {}
self.periodic_step = False
self.periodic_variables = {}
def format_excel_df(self, df, is_cond_df=False, point_prop=None):
df_new = df.reset_index().drop([0, 1], axis=1)
cols = ['step%d' % i for i in range(len(df_new.columns) - 2)]
cols = ['variable_name', 'acceptable_bounds'] + cols
df_new.columns = cols
if not is_cond_df:
df_new['variable_name'] = df_new['variable_name'].map(lambda x: point_prop.loc[point_prop['name_in_test'] == x].name[0])
return df_new.set_index('variable_name').T
else:
df_new = df_new.set_index('variable_name').T
df_new.loc[df_new['or'] == 1, 'VariableName'] = df_new.loc[df_new['or'] == 1, 'VariableName'].map(lambda x: point_prop.loc[point_prop["name_in_test"] == x].name[0])
time_vals = df_new.loc[df_new['ClkTime'].notnull()].index
cond_time = pd.to_datetime(df_new.loc[time_vals, 'ClkTime'], format="%H:%M:%S")
df_new.loc[time_vals, 'ClkTime'] = cond_time.dt.hour * 3600 + cond_time.dt.minute * 60 + cond_time.dt.second
return df_new
def read_points(self):
for point in sorted(self.point_properties.name.values):
var_name_in_test = self.point_properties.loc[point].name_in_test
self.points[var_name_in_test] = self.controller.device[point].value
return self.points
def print_points(self, to_csv=False, name=None):
points = self.read_points()
for k in sorted(points):
print("%s: %s" % (k, str(points[k])))
print()
if to_csv:
file = self.FILE_FOLDER + name + "_values.csv"
if not os.path.exists(file):
fp = open(file, "w")
column_names = 'time,' + ','.join(list(points.keys())) + '\n'
fp.write(column_names)
else:
fp = open(file, "a")
values = time.strftime("%Y-%m-%d %H:%M:%S")+','+','.join([str(value) for value in points.values()])+'\n'
fp.write(values)
def save_test_times(self, to_csv=False, name=None, step=None, st=None, et=None, duration=None):
if to_csv:
file = self.FILE_FOLDER + name + "_test_times.csv"
if not os.path.exists(file):
fp = open(file, "w")
column_names = 'step,start_time,end_time,duration\n'
fp.write(column_names)
else:
fp = open(file, "a")
values = "%d,%f,%f,%f\n"%(step, st, et, duration)
fp.write(values)
def start_test(self, to_csv=False, name=None):
output_acceptable_bounds = self.acceptable_op_bounds.to_dict()
start_time = time.time()
for i in range(1, self.ip.shape[0]):
self.current_step = i
print("starting step %d"%i)
ip = self.ip.iloc[i].to_dict()
cond = self.cond.iloc[i]
expected_op = self.op.iloc[i].to_dict()
# self.controller.set_values(point_value_dict = ip)
self.set_values(variable_value_dict=ip)
print("Successfully set input values=================================")
print()
step_start_time = time.time()
self.test_conditions(condition=cond, st=step_start_time, to_csv=to_csv, name=name)
print("Conditions met. Current values = ")
self.print_points(to_csv=to_csv, name=name)
actual_outputs = self.get_current_variable_values(variable_list = self.op.columns.values)
self.step_outputs[self.current_step] = actual_outputs
if i > 1:
print("Checking if outputs match the expected values")
assertion_op = self.assert_output(expected_op_dict = expected_op, actual_output_dict=actual_outputs, acceptable_bounds_dict = output_acceptable_bounds)
if not assertion_op:
end_time = time.time()
time_elapsed = round((end_time - start_time)/60, 2)
print("Test failed! Total time = %f minutes"%round(time_elapsed, 2))
self.save_test_times(to_csv=to_csv, name=name, step=-1, st=start_time, et=end_time,
duration=time_elapsed)
return
step_end_time = time.time()
step_time_elapsed = round((step_end_time - step_start_time)/60, 2)
print("Passed step %d; Time taken for this step = %f minutes"%(i, round(step_time_elapsed, 2)))
self.save_test_times(to_csv=to_csv, name=name, step=i, st=step_start_time, et=step_end_time, duration=step_time_elapsed)
else:
print("not checking first step values")
print("moving to the next step")
print()
end_time = time.time()
time_elapsed = round((end_time - start_time) / 60, 2)
print("Controller passed the test successfully! Total time = %f minutes"%round(time_elapsed, 2))
self.save_test_times(to_csv=to_csv, name=name, step=999, st=start_time, et=end_time,
duration=time_elapsed)
return
def set_values(self, variable_value_dict):
# start with assumption that there are no ramping variables in this step
self.ramp_step = False
self.ramp_variables = {}
self.periodic_step = False
self.periodic_variables = {}
for key in variable_value_dict:
val = variable_value_dict[key]
if type(val) == str:
# remove all whitespaces
val = val.replace(" ","")
if val.startswith("ramp("):
ramp_params_dict = self.get_ramp_parameter_dict(val=val)
self.ramp_variables[key] = ramp_params_dict
value_to_set = ramp_params_dict['ramp_start']
elif val.startswith("periodic("):
periodic_params_dict = self.get_periodic_parameter_dict(val=val)
self.periodic_variables[key] = periodic_params_dict
value_to_set = periodic_params_dict['periodic_start']
elif val.startswith("="):
expression = val[1:]
value_to_set = self.evaluate_expression(expression=expression)
else:
if val.lower() in ['open', 'present', 'on']:
value_to_set = 'active'
elif val.lower() in ['closed', 'absent', 'off']:
value_to_set = 'inactive'
else:
value_to_set = val
else:
# TODO: handle units == 'percent'
value_to_set = val
var_name_in_test = self.point_properties.loc[key].name_in_test
print("Setting input %s to %s"%(var_name_in_test, value_to_set))
self.controller.device[key] = value_to_set
def get_ramp_parameter_dict(self, val, default_ramp_period=10):
val = val.split("ramp(")[1][:-1]
string_parameters = val.split(';')
ramp_params = []
for param in string_parameters:
if param.startswith("="):
expression = param[1:]
val_expression = self.evaluate_expression(expression=expression)
ramp_params.append(val_expression)
else:
ramp_params.append(float(param))
ramp_params_dict = {}
# if start == end, no ramping
if ramp_params[0] != ramp_params[1]:
self.ramp_step = True
ramp_params_dict['ramp_start'] = ramp_params[0]
ramp_params_dict['ramp_end'] = ramp_params[1]
# convert ramp rate to value per second
ramp_params_dict['ramp_rate'] = ramp_params[2]/60.0
if len(ramp_params) == 4:
ramp_params_dict['ramp_period'] = ramp_params[3]
else:
ramp_params_dict['ramp_period'] = default_ramp_period
return ramp_params_dict
def get_periodic_parameter_dict(self, val, default_period = 10):
val = val.split("periodic(")[1][:-1]
string_parameters = val.split(";")
periodic_params = []
for param in string_parameters:
if param.startswith("="):
periodic_params.append(param[1:])
else:
periodic_params.append(float(param))
self.periodic_step = True
periodic_params_dict = {}
periodic_params_dict['periodic_start'] = self.evaluate_expression(expression=periodic_params[0])
periodic_params_dict['periodic_expression'] = periodic_params[0]
if len(periodic_params) == 2:
periodic_params_dict['period'] = int(periodic_params[1])
else:
periodic_params_dict['period'] = default_period
return periodic_params_dict
def set_ramp_value(self, variable, params, seconds_since_start):
ramp_start = params['ramp_start']
ramp_end = params['ramp_end']
ramp_rate = params['ramp_rate']
ramp_period = params['ramp_period']
if seconds_since_start % ramp_period == 0:
current_period = seconds_since_start / ramp_period
if ramp_start < ramp_end:
value_to_set = ramp_start + ramp_rate * current_period * ramp_period
if value_to_set > ramp_end:
value_to_set = ramp_end
elif ramp_start > ramp_end:
value_to_set = ramp_start - ramp_rate * current_period * ramp_period
if value_to_set < ramp_end:
value_to_set = ramp_end
current_value = self.controller.device[variable].value
if round(value_to_set, 2) != round(current_value, 2):
var_name_in_test = self.point_properties.loc[variable].name_in_test
print("Ramping input %s to %f" % (var_name_in_test, value_to_set))
print()
self.controller.device[variable] = value_to_set
def set_periodic_value(self, variable, params, seconds_since_start):
periodic_expression = params['periodic_expression']
period = params['period']
if seconds_since_start%period == 0:
value_to_set = self.evaluate_expression(expression=periodic_expression)
current_value = self.controller.device[variable].value
if round(value_to_set, 2) != round(current_value, 2):
var_name_in_test = self.point_properties.loc[variable].name_in_test
print("Periodic: Changing variable %s to %f" % (var_name_in_test, value_to_set))
print()
self.controller.device[variable] = value_to_set
def test_conditions(self, condition, st, sleep_interval=None, verbose=False, to_csv=False, name=None):
print("step = %d " % self.current_step)
current_time = time.time()
last_print = None
while current_time - st <= condition['ClkTime']:
seconds_since_start = int(current_time - st)
if self.ramp_step:
for variable in self.ramp_variables:
params = self.ramp_variables[variable]
self.set_ramp_value(variable=variable, params=params, seconds_since_start=seconds_since_start)
if self.periodic_step:
for variable in self.periodic_variables:
params = self.periodic_variables[variable]
self.set_periodic_value(variable=variable, params=params, seconds_since_start=seconds_since_start)
if verbose:
print("current time = %f, wait until %f" % (current_time - st, condition['ClkTime']))
if condition['or'] == 1:
output_variable_to_check = condition['VariableName']
output_value_to_check = condition['VariableValue']
if type(output_value_to_check) == str:
operator = re.findall("\A\D+", output_value_to_check)
if len(operator) == 1:
operator = operator[0]
else:
#TODO: handle this better
raise Exception("Invalid condition value in step %d for variable %s"%(self.current_step, output_variable_to_check))
output_value_to_check = output_value_to_check.split(operator)[1]
if output_value_to_check.endswith("%"):
output_value_to_check = float(output_value_to_check[:-1])/100
else:
output_value_to_check = float(output_value_to_check)
else:
operator = ">="
actual_output_variable_value = self.controller.device[output_variable_to_check].value
# handle percent values
if self.point_properties.loc[output_variable_to_check].units_state == 'percent':
actual_output_variable_value = actual_output_variable_value/100
if self.evaluate_boolean_expression(operator=operator, actual_value=actual_output_variable_value, expected_value=output_value_to_check):
print("condition satisfied, variable %s value %f %s condition value %f"%(output_variable_to_check, actual_output_variable_value, operator, output_value_to_check))
print()
return
if seconds_since_start%60 == 0:
if last_print == None or last_print != seconds_since_start/60:
last_print = seconds_since_start/60
print("Completed minute %d of step %d of the test; Current values=" % (int(seconds_since_start/60), self.current_step))
self.print_points(to_csv=to_csv, name=name)
if sleep_interval:
time.sleep(sleep_interval)
current_time = time.time()
print("wait time condition met")
def evaluate_boolean_expression(self, operator, actual_value, expected_value):
if operator == ">" and actual_value > expected_value:
return True
elif operator == ">=" and actual_value >= expected_value:
return True
elif operator == "<" and actual_value < expected_value:
return True
elif operator == "<=" and actual_value <= expected_value:
return True
elif operator == "==" and actual_value == expected_value:
return True
else:
return False
def get_current_variable_values(self, variable_list):
vals = {}
for var in variable_list:
vals[var] = self.controller.device[var].value
return vals
def assert_output(self, expected_op_dict, actual_output_dict, acceptable_bounds_dict):
for key in expected_op_dict:
expected_val = expected_op_dict[key]
actual_val = actual_output_dict[key]
error_bound = acceptable_bounds_dict[key]
if type(actual_val) == str:
if actual_val == 'inactive':
actual_val = 0
else:
actual_val = 1
if expected_val == "Any":
continue
elif type(expected_val) == str:
if "last" in expected_val:
operator = expected_val.split('last')[0]
variable = key
expected_val = self.step_outputs[self.current_step - 1][variable]
if self.evaluate_boolean_expression(operator=operator, actual_value=actual_val, expected_value=expected_val):
continue
else:
var_name = self.point_properties.loc[self.point_properties.name == key].name_in_test.values[0]
print("For variable %s [or %s], actual value = %f not %s expected value = %f"%(key, var_name, actual_val, operator, expected_val))
return False
if expected_val.startswith("="):
expression = expected_val[1:]
expected_value = self.evaluate_expression(expression=expression)
if abs(expected_value - actual_val) > error_bound:
var_name = self.point_properties.loc[self.point_properties.name == key].name_in_test.values[0]
print ("outside bounds for %s [or %s], actual value = %f, expected value = %f, bounds = %f" % (
key, var_name, actual_val, expected_val, error_bound))
return False
else:
if self.point_properties.loc[key].units_state == 'percent':
actual_val = actual_val/100
if abs(expected_val - actual_val) > error_bound:
var_name = self.point_properties.loc[self.point_properties.name == key].name_in_test.values[0]
print ("outside bounds for %s [or %s], actual value = %f, expected value = %f, bounds = %f"%(key, var_name, actual_val, expected_val, error_bound))
return False
return True
def evaluate_expression(self, expression):
if expression.startswith("="):
expression = expression[1:]
while expression.find(')') != -1:
e_loc = expression.find(')')
s_loc = expression[:e_loc].rfind('(')
op = self.get_value_from_expression(expression=expression[s_loc + 1:e_loc])
expression = expression.replace(expression[s_loc:e_loc + 1], str(op))
return self.get_value_from_expression(expression=expression)
def get_value_from_expression(self, expression):
operator_found = False
result = None
for operator in ['+', '-', '*', '/']:
if operator in expression:
operator_found = True
parts = expression.split(operator)
for part in parts:
current_res = self.get_value_from_expression(expression=part)
if result:
if operator == '+':
result = result + current_res
elif operator == '-':
result = result - current_res
elif operator == '*':
result = result * current_res
elif operator == '/':
result = result / current_res
else:
result = current_res
break
if operator_found:
return result
else:
names_df = self.point_properties.loc[self.point_properties.name_in_test == expression]
if not names_df.empty:
var_name = names_df.name.values[0]
return self.controller.device[var_name].value
else:
try:
float_value = float(expression)
except Exception as e:
raise Exception("cannot find variable %s"%expression)
return float_value
def testShortName(self):
firstDevice = Device("I-K01/VAC/I-K01CAB05-VAC-IPCU1", None, None)
secondDevice = Device("R1-SGA/MAG/R1-SGACAB14-MAG-PS04", None, None)
self.assertEqual(firstDevice.getShortName(), "IPCU1")
self.assertEqual(secondDevice.getShortName(), "PS04")
def testSectionName(self):
device = Device("I-TL/VAC/I-TL-CAB02-VAC-IPCU1", None, None)
self.assertEqual(device.getSectionName(), "I-TL")
device = Device("I-S00/MAG/I-S00-MAG-COBX2", None, None)
self.assertEqual(device.getSectionName(), "I-S00")
device = Device("I-K01/VAC/I-K01CAB05-VAC-IPCU1", None, None)
self.assertEqual(device.getSectionName(), "I-K01")
device = Device("R1-SGA/MAG/CAB1R1-SGA4-MAG-PS04", None, None)
self.assertEqual(device.getSectionName(), "R1-SGA")
def setUp(self):
self.device = Device()
self.device2 = Device("Jumpy Whale")
def testGenerateSimpleName(self):
device = Device("I-K01/VAC/I-K01CAB05-VAC-IPCU1", None, None)
self.assertEqual(device.generateSimpleName(),
"ik01vacik01cab05vacipcu1")
def testLinacElement(self):
device = Device("I-K01/VAC/I-K01CAB05-VAC-IPCU1", None, None)
self.assertEqual(device.isLinacElement(), True)
device = Device("R1-SGA/MAG/R1-SGACAB14-MAG-PS04", None, None)
self.assertEqual(device.isLinacElement(), False)
def testAddDeviceToSubsection(self):
section = self.linac.addSection("I-S01", None, 200)
subsection = section.addSubsection("I-S01B", None, 50)
device = Device("I-S01B/ab/cd", None, [0, 20])
self.linac.addDevice(device)
self.assertEqual(device.section, subsection)
