Datasets:
thisisanshgupta
/
Pycode

Dataset card Data Studio Files
xet
Community
text
stringlengths
0
828
voltage: measured voltage (V)
force: actuation force (uN/mm)
area: actuated area (mm^2)
Z_device_filtered: filtered device impedance for actuated area (Ohms)
capacitance_filtered: filtered device capacitance for actuated area (F)
x_position_filtered: filtered x-position of the drop (mm)
dxdt_filtered: filtered instantaneous velocity of the drop (mm/s)
Z_device: device impedance for actuated area (Ohms)
capacitance: device capacitance for actuated area (F)
x_position: x-position of the drop (mm)
dxdt: instantaneous velocity of the drop (mm/s)
dx: difference in the drop's x-position over the course of the step (mm)
dt: time the drop is considered to have been ""moving"" (s)
mean_velocity: mean drop velocity (mm/s)
peak_velocity: peak drop velocity calculated from filtered instantaneous
velocity (mm/s)
window_size: windows size used for Savitzky-Golay filter (# bins)
filter_order: order used for Savitzky-Golay filter (integer)
""""""
window_size = self._get_window_size()
L = np.sqrt(self.area)
velocity_results = self.mean_velocity(Lx=L)
mean_velocity = None
peak_velocity = None
dx = 0
dt = 0
dxdt = np.zeros(len(self.time))
dxdt_filtered = np.zeros(len(self.time))
# if the window size is too small for filtering, set filter_order to None
if filter_order and window_size and window_size < filter_order + 2:
filter_order = None
if velocity_results and velocity_results['dx']:
mean_velocity = velocity_results['p'][0] * 1e3
dx = velocity_results['dx']
dt = velocity_results['dt'] * 1e-3 # convert to seconds
t, dxdt = self.dxdt(Lx=L)
# interpolate dxdt to use the same time points as the impedance values.
dxdt = np.interp(self.time,
t, dxdt) * 1e3 # multiply by 1000 to convert to mm/s
dxdt = np.ma.masked_invalid(dxdt)
t, dxdt_filtered = self.dxdt(filter_order=filter_order, Lx=L)
# interpolate dxdt_filtered to use the same time points as the impedance values.
dxdt_filtered = np.interp(self.time,
t, dxdt_filtered) * 1e3 # multiply by 1000 to convert to mm/s
dxdt_filtered = np.ma.masked_invalid(dxdt_filtered)
# calculate peak velocity from filtered data
peak_velocity = np.max(dxdt_filtered)
index = pd.Index(self.time * 1e-3, name='step_time')
df = pd.DataFrame({'target_voltage': self.voltage, # V
'voltage': self.V_actuation(), # V
'force': self.force(Ly=1.0) * 1e6, # uN/mm
'Z_device_filtered': self.Z_device(filter_order=filter_order), # Ohms
'capacitance_filtered': self.capacitance(filter_order=filter_order), # F
'x_position_filtered': self.x_position(filter_order=filter_order), # mm
'dxdt_filtered': dxdt_filtered, # mm/s
'Z_device': self.Z_device(), # Ohms
'capacitance': self.capacitance(), # F
'x_position': self.x_position(), # mm
'dxdt': dxdt, # mm/s
}, index=index)
df['frequency'] = self.frequency
df['area'] = self.area # mm^2
df['dx'] = dx # mm
df['dt'] = dt # s
df['mean_velocity'] = mean_velocity # mm/s
df['peak_velocity'] = peak_velocity # mm/s
df['window_size'] = window_size
df['filter_order'] = filter_order
# re-order columns
return df[[u'frequency', u'target_voltage', u'voltage', u'force', u'area',
u'Z_device_filtered', u'capacitance_filtered', u'x_position_filtered',
u'dxdt_filtered', u'Z_device', u'capacitance', u'x_position', u'dxdt',
u'dx', u'dt', u'mean_velocity', u'peak_velocity',
u'window_size', u'filter_order']]"
954,"def _upgrade(self):
""""""
Upgrade the serialized object if necessary.
Raises:
FutureVersionError: file was written by a future version of the
software.
""""""
logging.debug(""[FeedbackResultsSeries]._upgrade()"")
version = Version.fromstring(self.version)
logging.debug('[FeedbackResultsSeries] version=%s, class_version=%s',
str(version), self.class_version)
if version > Version.fromstring(self.class_version):
logging.debug('[FeedbackResultsSeries] version>class_version')
raise FutureVersionError(Version.fromstring(self.class_version),
version)