diff --git a/bicycledataprocessor/database.py b/bicycledataprocessor/database.py index a05202c..07bf9f7 100644 --- a/bicycledataprocessor/database.py +++ b/bicycledataprocessor/database.py @@ -93,9 +93,27 @@ def __init__(self, **kwargs): self.processedCols = ['FrameAccelerationX', 'FrameAccelerationY', 'FrameAccelerationZ', + 'LongitudinalRearContactAcceleration' + 'LateralRearContactAcceleration' + 'DownwardRearContactAcceleration' + 'LongitudinalFrontContactAcceleration' + 'LateralFrontContactAcceleration' + 'DownwardFrontContactAcceleration' + 'YawAngle' + 'FrontWheelYawAngle' + 'SteerTorque_Slip' + 'LongitudinalRearContactForce_Slip' + 'LateralRearContactForce_Slip' + 'LongitudinalFrontContactForce_Slip' + 'LateralFrontContactForce_Slip' + 'LongitudinalRearContactForce_Nonslip' + 'LateralRearContactForce_Nonslip' + 'LongitudinalFrontContactForce_Nonslip' + 'LateralFrontContactForce_Nonslip' 'PitchRate', 'PullForce', 'RearWheelRate', + 'FrontWheelRate', 'RollAngle', 'RollRate', 'ForwardSpeed', @@ -361,6 +379,45 @@ def create_task_table(self): pass self.close() + def select_runs(self, riders, maneuvers, environments): + """Returns a list of runs given a set of conditions. + + Parameters + ---------- + riders : list + All or a subset of ['Charlie', 'Jason', 'Luke']. + maneuvers : list + All or a subset of ['Balance', 'Balance With Disturbance', + 'Track Straight Line', 'Track Straight Line With Disturbance']. + environments : list + All or a subset of ['Horse Treadmill', 'Pavillion Floor']. + + Returns + ------- + runs : list + List of run numbers for the given conditions. + + """ + + self.open() + + table = self.database.root.runTable + + runs = [] + for row in table.iterrows(): + con = [] + con.append(row['Rider'] in riders) + con.append(row['Maneuver'] in maneuvers) + con.append(row['Environment'] in environments) + con.append(row['corrupt'] is not True) + con.append(int(row['RunID']) > 100) + if False not in con: + runs.append(row['RunID']) + + self.close() + + return runs + def sync_data(self, directory='exports/'): """Synchronizes data to the biosport website.""" user = 'biosport' diff --git a/bicycledataprocessor/main.py b/bicycledataprocessor/main.py index aa186a0..76487d7 100644 --- a/bicycledataprocessor/main.py +++ b/bicycledataprocessor/main.py @@ -7,6 +7,7 @@ from warnings import warn from ConfigParser import SafeConfigParser +import pdb # debugging #try: #from IPython.core.debugger import Tracer @@ -24,9 +25,26 @@ from tables import NoSuchNodeError import dtk.process as process -from dtk.bicycle import front_contact, benchmark_to_moore + +from dtk.bicycle import front_contact, benchmark_to_moore +from dtk.bicycle import front_wheel_yaw_angle, front_wheel_rate + +from dtk.bicycle import steer_torque_slip +from dtk.bicycle import contact_force_rear_longitudinal_slip +from dtk.bicycle import contact_force_rear_lateral_slip +from dtk.bicycle import contact_force_front_longitudinal_slip +from dtk.bicycle import contact_force_front_lateral_slip + +from dtk.bicycle import contact_force_rear_longitudinal_nonslip +from dtk.bicycle import contact_force_rear_lateral_nonslip +from dtk.bicycle import contact_force_front_longitudinal_nonslip +from dtk.bicycle import contact_force_front_lateral_nonslip + +from dtk.bicycle import contact_points_acceleration + import bicycleparameters as bp + # local dependencies from database import get_row_num, get_cell, pad_with_zeros, run_id_string import signalprocessing as sigpro @@ -730,11 +748,23 @@ def task_signals(self): print('Extracting the task portion from the data.') self.extract_task() - # compute task specific variables + # compute task specific variables* self.compute_yaw_angle() self.compute_rear_wheel_contact_rates() self.compute_rear_wheel_contact_points() self.compute_front_wheel_contact_points() + self.compute_front_wheel_yaw_angle() + self.compute_front_wheel_rate() + self.compute_contact_points_acceleration() + self.compute_steer_torque_slip() + self.compute_contact_force_rear_longitudinal_slip() + self.compute_contact_force_rear_lateral_slip() + self.compute_contact_force_front_longitudinal_slip() + self.compute_contact_force_front_lateral_slip() + self.compute_contact_force_rear_longitudinal_nonslip() + self.compute_contact_force_rear_lateral_nonslip() + self.compute_contact_force_front_longitudinal_nonslip() + self.compute_contact_force_front_lateral_nonslip() self.topSig = 'task' @@ -758,11 +788,13 @@ def compute_signals(self): # compute the quantities that aren't task specific self.compute_pull_force() + self.compute_frame_acceleration() self.compute_forward_speed() self.compute_steer_rate() self.compute_yaw_roll_pitch_rates() self.compute_steer_torque() + def truncate_signals(self): """Truncates the calibrated signals based on the time shift.""" @@ -845,9 +877,471 @@ def compute_front_wheel_contact_points(self): q9, q10 = f(q1, q2, q3, q4, q7, p['d1'], p['d2'], p['d3'], p['rr'], p['rf']) + q9.name = 'LongitudinalFrontContact' + q9.units = 'meter' + q10.name = 'LateralFrontContact' + q10.units = 'meter' + self.taskSignals['LongitudinalFrontContact'] = q9 self.taskSignals['LateralFrontContact'] = q10 + def compute_front_wheel_yaw_angle(self): + """Calculates the yaw angle of the front wheel.""" + + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(bp) + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + f = np.vectorize(front_wheel_yaw_angle) + q1_front_wheel = f(q1, q2, q4, mp['d1'], mp['d2'], mp['d3'], + bp['lam'], mp['rr'], mp['rf']) + + q1_front_wheel.name = 'FrontWheelYawAngle' + q1_front_wheel.units = 'radian' + self.taskSignals['FrontWheelYawAngle'] = q1_front_wheel + + def compute_front_wheel_rate(self): + """Calculates the front wheel rate, based on the Jason's data + of front_wheel_contact_point. Alternatively, you can use the + sympy to get the front_wheel_contact_rate directly first.""" + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + u10 = self.taskSignals['LateralFrontContact'].time_derivative() + + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(bp) + + f = np.vectorize(front_wheel_rate) + + u6 = f(q1, q2, q4, u9, u10, mp['d1'], mp['d2'], mp['d3'], + bp['lam'], mp['rr'], mp['rf']) + + u6.name = 'FrontWheelRate' + u6.units = 'radian/second' + self.taskSignals['FrontWheelRate'] = u6 + + def compute_steer_torque_slip(self): + """Calculate the steer torque on the front frame and back on the rear + frame, in E['3'] direction, under the slip condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + ic11 = mp['ic11'] + ic33 = mp['ic33'] + ic31 = mp['ic31'] + + V = self.taskSignals['ForwardSpeed'].mean() + + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u4 = self.taskSignals['SteerRate'] + u8 = self.taskSignals['LateralRearContactRate'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + u10 = self.taskSignals['LateralFrontContact'].time_derivative() + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u4d = u4.time_derivative() + u8d = self.taskSignals['LateralRearContactAcceleration'] + u10d = self.taskSignals['LateralFrontContactAcceleration'] + + f = np.vectorize(steer_torque_slip) + + steerTorque_slip = f(V, l1, l2, mc, ic11, ic33, ic31, q2, q4, + u1, u2, u4, u8, u9, u10, u1d, u2d, u4d, u8d, u10d) + + steerTorque_slip.name = 'SteerTorque_Slip' + steerTorque_slip.units = 'newton*meter' + self.taskSignals[steerTorque_slip.name] = steerTorque_slip + + def compute_contact_force_rear_longitudinal_slip(self): + """Calculate the longitudinal contact force of rear wheel under + the slip condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + ic22 = mp['ic22'] + + u3 = self.taskSignals['PitchRate'] + u5 = self.taskSignals['RearWheelRate'] + u6 = self.taskSignals['FrontWheelRate'] + u7 = self.taskSignals['LongitudinalRearContactRate'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + + u3d = u3.time_derivative() + u5d = u5.time_derivative() + u6d = u6.time_derivative() + u7d = self.taskSignals['LongitudinalRearContactAcceleration'] + u9d = self.taskSignals['LongitudinalFrontContactAcceleration'] + + f = np.vectorize(contact_force_rear_longitudinal_slip) + + Fx_r_s = f(l1, l2, mc, ic22, u3, u5, u6, u7, u9, u3d, u5d, u6d, u7d, u9d) + + Fx_r_s.name = 'LongitudinalRearContactForce_Slip' + Fx_r_s.units = 'newton' + self.taskSignals[Fx_r_s.name] = Fx_r_s + + def compute_contact_force_rear_lateral_slip(self): + """Calculate the lateral contact force of rear wheel under + the slip condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + ic11 = mp['ic11'] + ic22 = mp['ic22'] + ic33 = mp['ic33'] + ic31 = mp['ic31'] + + V = self.taskSignals['ForwardSpeed'].mean() + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u4 = self.taskSignals['SteerRate'] + u5 = self.taskSignals['RearWheelRate'] + u6 = self.taskSignals['FrontWheelRate'] + u7 = self.taskSignals['LongitudinalRearContactRate'] + u8 = self.taskSignals['LateralRearContactRate'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + u10 = self.taskSignals['LateralFrontContact'].time_derivative() + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u4d = u4.time_derivative() + u5d = u5.time_derivative() + u6d = u6.time_derivative() + u7d = self.taskSignals['LongitudinalRearContactAcceleration'] + u8d = self.taskSignals['LateralRearContactAcceleration'] + u9d = self.taskSignals['LongitudinalFrontContactAcceleration'] + u10d = self.taskSignals['LateralFrontContactAcceleration'] + + f = np.vectorize(contact_force_rear_lateral_slip) + + Fy_r_s = f(V, l1, l2, mc, ic11, ic22, ic33, ic31, + q1, q2, q4, u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, + u1d, u2d, u3d, u4d, u5d, u6d, u7d, u8d, u9d, u10d) + + Fy_r_s.name = 'LateralRearContactForce_Slip' + Fy_r_s.units = 'newton' + self.taskSignals[Fy_r_s.name] = Fy_r_s + + def compute_contact_force_front_longitudinal_slip(self): + """Calculate the longitudinal contact force of front wheel under + the slip condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + ic11 = mp['ic11'] + ic22 = mp['ic22'] + ic33 = mp['ic33'] + ic31 = mp['ic31'] + + V = self.taskSignals['ForwardSpeed'].mean() + + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u4 = self.taskSignals['SteerRate'] + u5 = self.taskSignals['RearWheelRate'] + u6 = self.taskSignals['FrontWheelRate'] + u7 = self.taskSignals['LongitudinalRearContactRate'] + u8 = self.taskSignals['LateralRearContactRate'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + u10 = self.taskSignals['LateralFrontContact'].time_derivative() + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u4d = u4.time_derivative() + u5d = u5.time_derivative() + u6d = u6.time_derivative() + u7d = self.taskSignals['LongitudinalRearContactAcceleration'] + u8d = self.taskSignals['LateralRearContactAcceleration'] + u9d = self.taskSignals['LongitudinalFrontContactAcceleration'] + u10d = self.taskSignals['LateralFrontContactAcceleration'] + + f = np.vectorize(contact_force_front_longitudinal_slip) + + Fx_f_s = f(V, l1, l2, mc, ic11, ic22, ic33, ic31, + q2, q4, u1, u2, u3, u4, u5, u6, u7, u8, u9, u10, + u1d, u2d, u3d, u4d, u5d, u6d, u7d, u8d, u9d, u10d) + + Fx_f_s.name = 'LongitudinalFrontContactForce_Slip' + Fx_f_s.units = 'newton' + self.taskSignals[Fx_f_s.name] = Fx_f_s + + def compute_contact_force_front_lateral_slip(self): + """Calculate the lateral contact force of front wheel under + the slip condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + ic11 = mp['ic11'] + ic33 = mp['ic33'] + ic31 = mp['ic31'] + + V = self.taskSignals['ForwardSpeed'].mean() + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u4 = self.taskSignals['SteerRate'] + u8 = self.taskSignals['LateralRearContactRate'] + u9 = self.taskSignals['LongitudinalFrontContact'].time_derivative() + u10 = self.taskSignals['LateralFrontContact'].time_derivative() + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u4d = u4.time_derivative() + u8d = self.taskSignals['LateralRearContactAcceleration'] + u10d = self.taskSignals['LateralFrontContactAcceleration'] + + f = np.vectorize(contact_force_front_lateral_slip) + + Fy_f_s = f(V, l1, l2, mc, ic11, ic33, ic31, + q1, q2, q4, u1, u2, u4, u8, u9, u10, u1d, u2d, u4d, u8d, u10d) + + Fy_f_s.name = 'LateralFrontContactForce_Slip' + Fy_f_s.units = 'newton' + self.taskSignals[Fy_f_s.name] = Fy_f_s + + def compute_contact_force_rear_longitudinal_nonslip(self): + """Calculate the longitudinal contact force of rear wheel under + the constraint condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u5 = self.taskSignals['RearWheelRate'] + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u5d = u5.time_derivative() + + f = np.vectorize(contact_force_rear_longitudinal_nonslip) + + Fx_r_ns = f(l1, l2, mc, q1, q2, u1, u2, u3, u5, u1d, u2d, u3d, u5d) + + Fx_r_ns.name = 'LongitudinalRearContactForce_Nonslip' + Fx_r_ns.units = 'newton' + self.taskSignals[Fx_r_ns.name] = Fx_r_ns + + def compute_contact_force_rear_lateral_nonslip(self): + """Calculate the lateral contact force of rear wheel under + the constraint condition""" + + #parameters + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + l1 = mp['l1'] + l2 = mp['l2'] + mc = mp['mc'] + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u5 = self.taskSignals['RearWheelRate'] + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u5d = u5.time_derivative() + + f = np.vectorize(contact_force_rear_lateral_nonslip) + + Fy_r_ns = f(l1, l2, mc, q1, q2, u1, u2, u3, u5, u1d, u2d, u3d, u5d) + + Fy_r_ns.name = 'LateralRearContactForce_Nonslip' + Fy_r_ns.units = 'newton' + self.taskSignals[Fy_r_ns.name] = Fy_r_ns + + def compute_contact_force_front_longitudinal_nonslip(self): + """Calculate the longitudinal contact force of front wheel under + the constraint condition""" + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u4 = self.taskSignals['SteerRate'] + u6 = self.taskSignals['FrontWheelRate'] + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u4d = u4.time_derivative() + u6d = u6.time_derivative() + + f = np.vectorize(contact_force_front_longitudinal_nonslip) + + Fx_f_ns = f(q1, q2, q4, u1, u2, u3, u4, u6, u1d, u2d, u3d, u4d, u6d) + + Fx_f_ns.name = 'LongitudinalFrontContactForce_Nonslip' + Fx_f_ns.units = 'newton' + self.taskSignals[Fx_f_ns.name] = Fx_f_ns + + def compute_contact_force_front_lateral_nonslip(self): + """Calculate the lateral contact force of front wheel under + the constraint condition""" + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u4 = self.taskSignals['SteerRate'] + u6 = self.taskSignals['FrontWheelRate'] + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u4d = u4.time_derivative() + u6d = u6.time_derivative() + + f = np.vectorize(contact_force_front_lateral_nonslip) + + Fy_f_ns = f(q1, q2, q4, u1, u2, u3, u4, u6, u1d, u2d, u3d, u4d, u6d) + + Fy_f_ns.name = 'LateralFrontContactForce_Nonslip' + Fy_f_ns.units = 'newton' + self.taskSignals[Fy_f_ns.name] = Fy_f_ns + + def compute_contact_points_acceleration(self): + """Calculates the acceleration of the contact points of front and rear + wheels.""" + + AccX= self.taskSignals['FrameAccelerationX'] + AccY = self.taskSignals['FrameAccelerationY'] + AccZ = self.taskSignals['FrameAccelerationZ'] + + q1 = self.taskSignals['YawAngle'] + q2 = self.taskSignals['RollAngle'] + q4 = self.taskSignals['SteerAngle'] + + u1 = self.taskSignals['YawRate'] + u2 = self.taskSignals['RollRate'] + u3 = self.taskSignals['PitchRate'] + u4 = self.taskSignals['SteerRate'] + u5 = self.taskSignals['RearWheelRate'] + u6 = self.taskSignals['FrontWheelRate'] + + u1d = u1.time_derivative() + u2d = u2.time_derivative() + u3d = u3.time_derivative() + u4d = u4.time_derivative() + u5d = u5.time_derivative() + u6d = u6.time_derivative() + + bp = self.bicycleRiderParameters + mp = benchmark_to_moore(self.bicycleRiderParameters) + + d1 = mp['d1'] + d2 = mp['d2'] + d3 = mp['d3'] + rr = mp['rr'] + rf = mp['rf'] + ds1 = self.bicycle.parameters['Measured']['ds1'] + ds3 = self.bicycle.parameters['Measured']['ds3'] + s3 = ds3 + s1 = ds1 + mp['l4'] + + f = np.vectorize(contact_points_acceleration) + + u7d, u8d, u11d, u9d, u10d, u12d = f(AccX, AccY, AccZ, + q1, q2, q4, + u1, u2, u3, u4, u5, u6, u1d, u2d, u3d, u4d, u5d, u6d, + d1, d2, d3, rr, rf, s1, s3) + + u7d.name = 'LongitudinalRearContactAcceleration' + u7d.units = 'meter/second/second' + u8d.name = 'LateralRearContactAcceleration' + u8d.units = 'meter/second/second' + u11d.name = 'DownwardRearContactAcceleration' + u11d.units = 'meter/second/second' + u9d.name = 'LongitudinalFrontContactAcceleration' + u9d.units = 'meter/second/second' + u10d.name = 'LateralFrontContactAcceleration' + u10d.units = 'meter/second/second' + u12d.name = 'DownwardFrontContactAcceleration' + u12d.units = 'meter/second/second' + + self.taskSignals[u7d.name] = u7d + self.taskSignals[u8d.name] = u8d + self.taskSignals[u11d.name] = u11d + self.taskSignals[u9d.name] = u9d + self.taskSignals[u10d.name] = u10d + self.taskSignals[u12d.name] = u12d + def compute_rear_wheel_contact_rates(self): """Calculates the rates of the wheel contact points in the ground plane.""" @@ -1022,7 +1516,7 @@ def compute_yaw_roll_pitch_rates(self): rollAngle = rollAngle.convert_units('radian') yr, rr, pr = sigpro.yaw_roll_pitch_rate(omegaX, omegaY, omegaZ, lam, - rollAngle=rollAngle) + rollAngle=rollAngle) yr.units = 'radian/second' yr.name = 'YawRate' rr.units = 'radian/second' @@ -1083,6 +1577,36 @@ def compute_pull_force(self): pullForce.units = 'newton' self.computedSignals[pullForce.name] = pullForce + def compute_frame_acceleration(self): + """ + Computes the frame acceleration in inertial frame about body-fixed + coordinates, taken from the NV-100signal. + + """ + try: + AccX = self.truncatedSignals['AccelerationX'] + AccY = self.truncatedSignals['AccelerationY'] + AccZ = self.truncatedSignals['AccelerationZ'] + + except AttributeError: + print 'Accelerations from truncatedSignals were not available,'\ + ' Accelerations for computedSignals are not computed' + else: + AccX = AccX.convert_units('meter/second/second') + AccX.name = 'FrameAccelerationX' + AccX.units = 'meter/second/second' + self.computedSignals[AccX.name] = AccX + + AccY = AccY.convert_units('meter/second/second') + AccY.name = 'FrameAccelerationY' + AccY.units = 'meter/second/second' + self.computedSignals[AccY.name] = AccY + + AccZ = AccZ.convert_units('meter/second/second') + AccZ.name = 'FrameAccelerationZ' + AccZ.units = 'meter/second/second' + self.computedSignals[AccZ.name] = AccZ + def __str__(self): '''Prints basic run information to the screen.''' diff --git a/bicycledataprocessor/select_runs.py b/bicycledataprocessor/select_runs.py new file mode 100644 index 0000000..338526f --- /dev/null +++ b/bicycledataprocessor/select_runs.py @@ -0,0 +1,42 @@ +import bicycledataprocessor as bdp + +def select_runs(riders, maneuvers, environments): + """Returns a list of runs given a set of conditions. + + Parameters + ---------- + riders : list + All or a subset of ['Charlie', 'Jason', 'Luke']. + maneuvers : list + All or a subset of ['Balance', 'Balance With Disturbance', 'Track Straight Line', 'Track Straight Line With Disturbance']. + environments : list + All or a subset of ['Horse Treadmill', 'Pavillion Floor']. + + Returns + ------- + runs : list + List of run numbers for the given conditions. + + """ + + dataset = bdp.DataSet() + dataset.open() + + table = dataset.database.root.runTable + + runs = [] + for row in table.iterrows(): + con = [] + con.append(row['Rider'] in riders) + con.append(row['Maneuver'] in maneuvers) + con.append(row['Environment'] in environments) + con.append(row['corrupt'] is not True) + con.append(int(row['RunID']) > 100) + if False not in con: + runs.append(row['RunID']) + + dataset.close() + + return runs + + diff --git a/defaults.cfg b/defaults.cfg index d0df2b1..b815bb2 100644 --- a/defaults.cfg +++ b/defaults.cfg @@ -1,5 +1,5 @@ [data] -base = /media/Data/Documents/School/UC Davis/Bicycle Mechanics +base = /home/stefenstudy/bicycle/bi_pypa pathToDatabase = %(base)s/BicycleDataProcessor/InstrumentedBicycleData.h5 pathToCorruption = %(base)s/BicycleDataProcessor/data-corruption.csv pathToRunMat = %(base)s/BicycleDAQ/data