diff --git a/README.md b/README.md index bb3731a..db35af6 100644 --- a/README.md +++ b/README.md @@ -126,6 +126,7 @@ Additional contributions by (new contributors, add yourself here): * Alexander Merino * Tristan Long * Kayla Barton +* Christopher McLean # Copyright diff --git a/devtools/data_creation/correlation_data.py b/devtools/data_creation/correlation_data.py index cf00d39..9e25560 100644 --- a/devtools/data_creation/correlation_data.py +++ b/devtools/data_creation/correlation_data.py @@ -35,11 +35,11 @@ def generate_data(self): def configure(self, tile_x, tile_y, model_positions, convergence_step=None): self.model_positions = model_positions - self.slices = [] + self.slabs = [] batch_start_index = 0 while batch_start_index < self.num_traces: entry_count = min(self.batch_size, self.num_traces - batch_start_index) - self.slices.append(slice(batch_start_index, batch_start_index+entry_count)) + self.slabs.append(slice(batch_start_index, batch_start_index+entry_count)) batch_start_index += entry_count return 1 @@ -53,25 +53,25 @@ def get_traces(self): def get_key(self): return self.key - def get_byte_batch(self, slice, model_pos): + def get_byte_batch(self, slab, model_pos): - return [self.plaintext[slice, [model_pos]], self.key[[model_pos]], self.traces[slice,:]] + return [self.plaintext[slab, [model_pos]], self.key[[model_pos]], self.traces[slab,:]] def get_batches_by_byte(self, tile_x, tile_y, model_pos): - for slice in self.slices: - yield self.get_byte_batch(slice, model_pos) + for slab in self.slabs: + yield self.get_byte_batch(slab, model_pos) - def get_batch(self, slice): + def get_batch(self, slab): - return [self.plaintext[slice,self.model_positions], self.key[self.model_positions], self.traces[slice,:]] + return [self.plaintext[slab,self.model_positions], self.key[self.model_positions], self.traces[slab,:]] def get_batches_all(self, tile_x, tile_y): - for slice in self.slices: - yield self.get_batch(slice) + for slab in self.slabs: + yield self.get_batch(slab) def get_batch_index(self, index): - if index >= len(self.slices): + if index >= len(self.slabs): return [] - return [self.plaintext[self.slices[index], self.model_positions], self.key[self.model_positions], self.traces[self.slices[index], :]] \ No newline at end of file + return [self.plaintext[self.slabs[index], self.model_positions], self.key[self.model_positions], self.traces[self.slabs[index], :]] diff --git a/license_check.ini b/license_check.ini index 1d428c1..ba458dd 100644 --- a/license_check.ini +++ b/license_check.ini @@ -24,6 +24,7 @@ authorized_licenses: Historical Permission Notice and Disclaimer (HPND) Other/Proprietary The Unlicense (Unlicense) + CMU License (MIT-CMU) unauthorized_licenses: gpl v3 diff --git a/src/scarr/container/container.py b/src/scarr/container/container.py index b7954ad..eefd135 100755 --- a/src/scarr/container/container.py +++ b/src/scarr/container/container.py @@ -29,7 +29,7 @@ class Container: - byte_positions: The byte positions to be processed by the algorithm has a default value of [0] - tile_positions: The tile positions that are to have the byte positions processed default value of [(0,0)] """ - def __init__(self, options: ContainerOptions, Async = True, model_positions = [0], tile_positions = [(0,0)], filters = [], points=[], trace_index=[], slice=[], stride=1) -> None: + def __init__(self, options: ContainerOptions, Async = True, model_positions = [0], tile_positions = [(0,0)], filters = [], points=[], trace_index=[], slab=[], stride=1) -> None: self.engine = options.engine self.data = options.handler self.data2 = options.handler2 # second trace (only t-test) @@ -48,28 +48,28 @@ def __init__(self, options: ContainerOptions, Async = True, model_positions = [0 self.min_traces_length = 0 if len(points) > 0: - self.slice_index = points - self.time_slice = [] + self.slab_points = points + self.slab_range = [] self.stride = 1 self.sample_length = len(points) - elif len(slice) == 2 and stride > 1: - self.slice_index = [] - self.time_slice = slice + elif len(slab) == 2 and stride > 1: + self.slab_points = [] + self.slab_range = slab self.stride = stride - self.sample_length = math.ceil((self.time_slice[1] - self.time_slice[0]) / stride) - elif len(slice) == 2: - self.slice_index = [] - self.time_slice = slice + self.sample_length = math.ceil((self.slab_range[1] - self.slab_range[0]) / stride) + elif len(slab) == 2: + self.slab_points = [] + self.slab_range = slab self.stride = 1 - self.sample_length = int(self.time_slice[1] - self.time_slice[0]) + self.sample_length = int(self.slab_range[1] - self.slab_range[0]) elif stride > 1: - self.slice_index = [] - self.time_slice = [] + self.slab_points = [] + self.slab_range = [] self.stride = stride self.sample_length = math.ceil(self.data.sample_length / self.stride) else: - self.slice_index = [] - self.time_slice = [] + self.slab_points = [] + self.slab_range = [] self.stride = 1 self.sample_length = self.data.sample_length @@ -86,13 +86,13 @@ def configure(self, tile_x, tile_y, model_positions, convergence_step = None): for filter in self.filters: filter.configure(tile_x, tile_y) # int() casting needed for random typing linux bug - return int(self.data.configure(tile_x, tile_y, model_positions, self.slice_index, self.trace_index, self.time_slice, self.stride, convergence_step)) + return int(self.data.configure(tile_x, tile_y, model_positions, self.slab_points, self.trace_index, self.slab_range, self.stride, convergence_step)) def configure2(self, tile_x, tile_y, model_positions, convergence_step = None): for filter in self.filters: filter.configure(tile_x, tile_y) # int() casting needed for random typing linux bug - return int(self.data2.configure(tile_x, tile_y, model_positions, self.slice_index, self.trace_index, self.time_slice, self.stride, convergence_step)) + return int(self.data2.configure(tile_x, tile_y, model_positions, self.slab_points, self.trace_index, self.slab_range, self.stride, convergence_step)) def get_batches(self, tile_x, tile_y): for batch in self.data.get_batch_generator(): diff --git a/src/scarr/file_handling/trace_handler.py b/src/scarr/file_handling/trace_handler.py index 7ec09b5..f0ac736 100755 --- a/src/scarr/file_handling/trace_handler.py +++ b/src/scarr/file_handling/trace_handler.py @@ -26,7 +26,7 @@ def __init__(self, self.model_positions = None # How many rows are in the current observed directory of the file self.data_length = None - self.slices = None + self.slabs = None # Default directory of the zarr file self.current_tile = '0/0' # Default tile # Zarr group @@ -36,28 +36,28 @@ def __init__(self, self.traces_length = len(self.data['0/0/traces']) # Change the directory to the passed in tile - def configure(self, tile_x, tile_y, model_positions, slice_index=[], trace_index=[], time_slice=[], stride=1, convergence_step = None): + def configure(self, tile_x, tile_y, model_positions, slab_points=[], trace_index=[], slab_range=[], stride=1, convergence_step = None): try: self.model_positions = model_positions self.current_tile = f'{tile_x}/{tile_y}' self.data_length = len(self.data[f'{self.current_tile}{"/traces"}']) - if len(slice_index) > 0: - self.sample_slice = slice_index - elif len(time_slice) == 2 and stride > 1: - self.sample_slice = slice(time_slice[0], time_slice[1], stride) - elif len(time_slice) == 2: - self.sample_slice = slice(time_slice[0], time_slice[1]) + if len(slab_points) > 0: + self.sample_slab = slab_points + elif len(slab_range) == 2 and stride > 1: + self.sample_slab = slice(slab_range[0], slab_range[1], stride) + elif len(slab_range) == 2: + self.sample_slab = slice(slab_range[0], slab_range[1]) elif stride > 1: - self.sample_slice= slice(0, self.sample_length, stride) + self.sample_slab= slice(0, self.sample_length, stride) else: - self.sample_slice = slice(None) + self.sample_slab = slice(None) if len(trace_index) > 0: self.data_length = len(trace_index) - self.slices = self.create_batches_index(trace_index) + self.slabs = self.create_batches_index(trace_index) else: - self.slices = self.create_batches() + self.slabs = self.create_batches() if convergence_step is None: return 1 @@ -68,7 +68,7 @@ def configure(self, tile_x, tile_y, model_positions, slice_index=[], trace_index print("Error configuring tile") # Grab a batch and pass it back to the algorithm's run function - def grab(self, slice): + def grab(self, slab): # Declare and select data for the batch full_data = [None for i in range(4)] @@ -82,64 +82,64 @@ def grab(self, slice): index = 2 case _: continue - full_data[index] = self.select_single_column(column, slice) - full_data[3] = self.select_traces(slice) + full_data[index] = self.select_single_column(column, slab) + full_data[3] = self.select_traces(slab) # Pass batch to the algorithm's run function return full_data # Fetch data of a non-samples zarr array - def select_single_column(self, col_name, slice): + def select_single_column(self, col_name, slab): # Grab zarr array col_data = self.data[f'{self.current_tile}/{col_name}'] # Grab the actual data - data = col_data.get_orthogonal_selection((slice, self.model_positions)) + data = col_data.get_orthogonal_selection((slab, self.model_positions)) # Pass to grab return data # Specific function for grabbing sample data - def select_traces(self, slice): + def select_traces(self, slab): # Grab zarr array of samples traces = self.data[f'{self.current_tile}/traces'] # Grab the actual data - data = traces.get_orthogonal_selection((slice, self.sample_slice)) + data = traces.get_orthogonal_selection((slab, self.sample_slab)) # Pass to grab return data def get_batch_generator(self): - for batch_slice in self.slices: - yield self.grab(batch_slice) + for batch_slab in self.slabs: + yield self.grab(batch_slab) def get_batch_index(self, index): - if index >= len(self.slices): + if index >= len(self.slabs): return [] - return self.grab(self.slices[index]) + return self.grab(self.slabs[index]) def create_batches(self): - slices = [] + slabs = [] batch_start_index = self.start while batch_start_index < self.data_length: entry_count = min(self.batch_size, self.data_length - batch_start_index) - slices.append(slice(batch_start_index, batch_start_index+entry_count)) + slabs.append(slice(batch_start_index, batch_start_index+entry_count)) batch_start_index += entry_count - return slices + return slabs def create_batches_index(self, index): - slices = [] + slabs = [] batch_start_index = 0 while batch_start_index < len(index): entry_count = min(self.batch_size, len(index) - batch_start_index) - slices.append(index[batch_start_index:batch_start_index+entry_count]) + slabs.append(index[batch_start_index:batch_start_index+entry_count]) batch_start_index += entry_count - return slices + return slabs def fetch(self, column, tile_x=0, tile_y=0, row_index = 0, col_index=None): if col_index is None: col_index = slice(None) column_data = self.data[f'{tile_x}/{tile_y}/{column}'] - return column_data.get_orthogonal_selection((row_index, col_index)) \ No newline at end of file + return column_data.get_orthogonal_selection((row_index, col_index))