def create_rods_with_length_process(length, length_error, real_kappa,
radius_correction_ratio, names,
index, states_queue):
"""
Process of method.
"""
name = names[index]
file_ = open(name, 'r')
state = SystemState(kappas=real_kappa, real_kappas=real_kappa,
allowed_kappa_error=0,
radius_correction_ratio=radius_correction_ratio,
id_string=name, zone_coords=settings.zone_coords)
data = methods.import_data(file_)
if not len(data):
states_queue.put([index, None])
return
for dataline in data:
try:
parameters = tuple(dataline)
new_rod = rod.Rod(parameters, kappa=real_kappa, real_length=real_kappa)
state.put_rod(new_rod)
except ValueError:
pass
file_.close()
file_ = None
state.compute_center_and_radius()
state.check_rods_with_length(length, length_error)
state = methods.compress_state(state)
states_queue.put([index, state])
def _compute_Q4_matrix(self, divisions):
"""
Computes Q4 matrix
"""
self.divide_in_circles(divisions)
subdivision = self._actual_subdivision
Q4_subsystems = []
for subsystem_ in subdivision:
subsystem = methods.decompress_state(subsystem_)
Q4 = [subsystem.center[0], subsystem.center[1]]
Q4.append(subsystem.Q4)
Q4_subsystems.append(methods.compress_state(Q4))
return Q4_subsystems
def _subsystems(self, possible_x_values, possible_y_values, rad, diff,
divisions, real_rad, rods_by_coords):
"""
Creates subsystems
"""
subsystems = []
centers = []
for actual_y in possible_y_values:
for actual_x in possible_x_values:
centers.append((actual_x, actual_y))
array2 = [self.center for dummy in range(len(centers))]
distances = methods.compute_distances(centers, array2)
array2 = None
x_min = min(possible_x_values)
y_min = min(possible_y_values)
for index in range(len(centers)):
distance = distances[index]
#time.sleep(settings.waiting_time_process)
if distance < self.radius:
center = centers[index]
available_rods = set([])
index_x = int((center[0]-x_min)/diff)
index_y = int((center[1]-y_min)/diff)
number_of_squares = self.coef*2 #int(self.coef/2)+1
for diff_index_x in range(number_of_squares):
for diff_index_y in range(number_of_squares):
try:
available_rods |= set(rods_by_coords[index_x-diff_index_x][index_y-diff_index_y])
available_rods |= set(rods_by_coords[index_x+diff_index_x][index_y+diff_index_y])
available_rods |= set(rods_by_coords[index_x-diff_index_x][index_y+diff_index_y])
available_rods |= set(rods_by_coords[index_x+diff_index_x][index_y-diff_index_y])
except IndexError:
continue
available_rods = list(available_rods)
subsystem = SubsystemState(center, rad, self.zone_coords,
available_rods, self._kappas, self._real_kappas,
self._allowed_kappa_error, real_rad)
subsystem.check_rods()
subsystems.append(methods.compress_state(subsystem))
return subsystems
def _create_subgroups_matrix(self, divisions):
"""
Put subsystems in a matrix form.
"""
if divisions != self._divisions:
self._reset()
if not len(self._subdivision_centers):
self.divide_in_circles(divisions)
act_sub = self._actual_subdivision
actual_y = methods.decompress_state(act_sub[0]).center[1]
row = []
subgroups_matrix = []
for index in range(len(act_sub)):
element = methods.decompress_state(act_sub[index])
element_y = element.center[1]
if element_y != actual_y:
subgroups_matrix.append(row)
row = []
actual_y = element_y
row.append(element)
subgroups_matrix.append(row)
act_sub = None
self._subdivision_centers = methods.compress_state(subgroups_matrix)
def create_rods_with_length(folder="./", length=10, length_error=.3, real_kappas=10,
radius_correction_ratio=0.1, file_range=[]):
"""
Create rods using rod length instead of kappa.
"""
print "--"*(len(inspect.stack())-2)+">"+"["+str(inspect.stack()[1][3])+"]->["+str(inspect.stack()[0][3])+"]: " + "Importing data"
names = methods.get_file_names(folder=folder)
if len(file_range) != 0:
try:
names = names[file_range[0]:file_range[1]]
except:
pass
num_of_files = len(names)
if not num_of_files:
print "No files to import.\n\n"
raise ValueError
states = [None for dummy_ in range(num_of_files)]
processes = []
states_queue = mp.Queue()
for index in range(num_of_files):
process = mp.Process(target=create_rods_with_length_process,
args=(length, length_error, real_kappas,
radius_correction_ratio, names,
index, states_queue))
processes.append(process)
num_processes = len(processes)
running, processes_left = methods.run_processes(processes)
finished_ = 0
previous_time = datetime.datetime.now()
counter = 0
time_left = None
times = []
print " "
empty_states = []
while finished_ < num_processes:
counter += 1
finished_ += 1
previous_time, counter, time_left, times = methods.print_progress(finished_, num_processes,
counter, times, time_left, previous_time)
[index, state] = states_queue.get()
if state is not None:
states[index] = state
else:
empty_states.append(index)
if len(processes_left):
new_process = processes_left.pop(0)
time.sleep(settings.waiting_time)
new_process.start()
for process in processes:
if process.is_alive():
process.terminate()
for empty_state in empty_states:
diff = 1
while True:
new_state = empty_state - diff
if states[new_state] is not None:
break
diff += 1
new_state = methods.decompress_state(states[new_state]).clone
states[empty_state] = methods.compress_state(new_state)
print(CURSOR_UP_ONE + ERASE_LINE + CURSOR_UP_ONE)
return names, states
