def main(args):
global main_path, tiles_margin, cardinal_RTemp, RT_PYTHON_number, MAX_PYTHON_process_number, TIME_SLICE
RT_PYTHON_number = args.rt_process
MAX_PYTHON_process_number = args.max_process
TIME_SLICE = args.time_slice
main_path = args.main_path
tiles_margin = scan_dish_margin(main_path)
cardinal_mem = pd.read_csv(os.path.join(main_path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
# !!! warning source
cardinal_RTemp = cardinal_mem.loc[
(cardinal_mem['experiment_complete'] == 0)
& (cardinal_mem['scheduling_method'] == 2) &
(cardinal_mem['analysis_complete'] == 0)]
while True:
time_start = time.time()
# for rt_scheduling
for this_F_index, this_F_row in cardinal_RTemp.iterrows(
): # only one experiment in iterrows()
if cardinal_RTemp.loc[this_F_index, 'experiment_complete'] == 0:
this_cfs = CurrentFolderStructs(this_F_index)
cardinal_RTemp.loc[
this_F_index,
['exp_B', 'exp_T', 'exp_S', 'exp_Z', 'exp_C', 'exp_M']] = [
this_cfs.current_B, this_cfs.current_T,
this_cfs.current_S, this_cfs.current_Z,
this_cfs.current_C, this_cfs.current_M
]
if os.path.exists(
os.path.join(this_F_index, 'ExperimentComplete.txt')):
with open(os.path.join(this_F_index, 'ExperimentComplete.txt'),
'r') as fin:
ec_str = fin.read()
os.remove(os.path.join(this_F_index, 'ExperimentComplete.txt'))
cardinal_RTemp.loc[this_F_index, 'experiment_complete'] = 1
rt_scheduling(this_F_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
temp_p_number = get_cpu_python_process()
print('$$$---Python Number: ', temp_p_number, '---$$$')
if temp_p_number > MAX_PYTHON_process_number:
print('!@#$%^&*(NOW sleep!)*&^%$#@!')
time.sleep(2)
while True:
if get_cpu_python_process() >= MAX_PYTHON_process_number:
time.sleep(2)
else:
break
if cardinal_RTemp.loc[
this_F_index,
'experiment_complete'] == 1 and cardinal_RTemp.loc[
this_F_index, 'analysis_complete'] == 1:
break
time_duration = time.time() - time_start
if cardinal_RTemp.loc[
this_F_index,
'analysis_complete'] == 1 and time_duration < TIME_SLICE:
time.sleep(TIME_SLICE)
print('Real Time Mission Complete!!!')
def main(args):
global main_path, tiles_margin, cardinal_mem, MAX_PYTHON_process_number, TIME_SLICE
main_path = args.main_path
tiles_margin = scan_dish_margin(main_path)
cardinal_mem = pd.read_csv(os.path.join(main_path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
MAX_PYTHON_process_number = args.max_process
TIME_SLICE = args.time_slice
for this_index, this_row in cardinal_mem.iterrows():
if this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 1:
print(this_index, 'Analysis Complete!!!')
next
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Catching up Analysising!!!')
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 0:
print(this_index, 'Real Time Analysising!!!')
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
# print('Mission Complete!!!')
# return True
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to Catching up!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 0 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to real time Analysising!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
# print('Mission Complete!!!')
# return True
else:
print('Method 3 ERROR! Wrong using method 3!')
exit('Method 3 ERROR! Wrong using method 3!')
print('Mission Complete!!!')
def main(args):
global main_path, tiles_margin, cardinal_mem, ONCE_PYTHON_number, MAX_PYTHON_process_number
ONCE_PYTHON_number = args.once_process
MAX_PYTHON_process_number = args.max_process
RT_Scheduling = False
main_path = args.main_path
tiles_margin = scan_dish_margin(main_path)
cardinal_mem = pd.read_csv(os.path.join(main_path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
for this_RT_index, this_RT_row in cardinal_mem.loc[
(cardinal_mem['experiment_complete'] == 0)
& (cardinal_mem['scheduling_method'] == 2) &
(cardinal_mem['analysis_complete'] == 0)].iterrows():
call_RT_Scheduling(main_path, args.B, args.T, args.S, args.Z, args.C,
args.M, args.rt_process, args.max_process,
args.time_slice)
RT_Scheduling = True
rt_count = 0
while True:
time_start = time.time()
# for row_scheduling
for this_F_index, this_F_row in cardinal_mem.loc[
(cardinal_mem['experiment_complete'] == 1)
& (cardinal_mem['scheduling_method'] == 1) &
(cardinal_mem['analysis_complete'] == 0)].iterrows():
row_scheduling(this_F_index, this_F_row, args.B, args.T, args.S,
args.Z, args.C, args.M)
temp_p_number = get_cpu_python_process()
print('$$$---Python Number: ', temp_p_number, '---$$$')
if temp_p_number > MAX_PYTHON_process_number:
print('!@#$%^&*(NOW sleep!)*&^%$#@!')
time.sleep(2)
while True:
if get_cpu_python_process() >= MAX_PYTHON_process_number:
time.sleep(2)
else:
break
# for col_scheduling
for this_F_index, this_F_row in cardinal_mem.loc[
(cardinal_mem['experiment_complete'] == 1)
& (cardinal_mem['scheduling_method'] == 2) &
(cardinal_mem['analysis_complete'] == 0)].iterrows():
col_scheduling(this_F_index, this_F_row, args.B, args.T, args.S,
args.Z, args.C, args.M)
temp_p_number = get_cpu_python_process()
print('$$$---Python Number: ', temp_p_number, '---$$$')
if temp_p_number > MAX_PYTHON_process_number:
print('!@#$%^&*(NOW sleep!)*&^%$#@!')
time.sleep(2)
while True:
if get_cpu_python_process() >= MAX_PYTHON_process_number:
time.sleep(2)
else:
break
# # for RT_scheduling
# time_duration = time.time() - time_start
# if RT_Scheduling:
# if cardinal_mem['analysis_complete'].sum() == cardinal_mem['analysis_complete'].size - 1:
# if time_duration < 15:
# time.sleep(15 - time_duration)
# else:
# rt_count += 1
# if rt_count == 3:
# rt_count = 0
# else:
# next
# if os.path.exists(os.path.join(main_path, 'Cardinal_RTemp.csv')):
# cardinal_RTemp = pd.read_csv(os.path.join(main_path, 'Cardinal_RTemp.csv'), header=0,
# index_col=0)
# cardinal_mem.loc[this_RT_index] = cardinal_RTemp.loc[this_RT_index]
# cardinal_mem.to_csv(path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
# print('collection complete!')
# if cardinal_RTemp.loc[this_RT_index, 'experiment_complete'] == 1 and cardinal_RTemp.loc[
# this_RT_index, 'analysis_complete'] == 1:
# RT_Scheduling = False
if cardinal_mem['analysis_complete'].sum(
) == cardinal_mem['experiment_complete'].sum():
break
print('Mission Complete!!!')
def main(args):
# time.sleep(30)
print('Cardinal Version: 1.0')
# ---the pandas display settings---
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
pd.set_option('max_colwidth', 100)
pd.set_option('display.width', None)
np.set_printoptions(threshold=None)
# ---the main data structures---
args_path = ''
cardinal_mem = pd.DataFrame(columns=[
'scheduling_method', 'experiment_complete', 'exp_B', 'exp_T', 'exp_S',
'exp_Z', 'exp_C', 'exp_M', 'analysis_complete', 'ana_B', 'ana_T',
'ana_S', 'ana_Z', 'ana_C', 'ana_M'
])
# index is path_date_name
# 'scheduling_method': 0 no processing
# 'scheduling_method': 1 row_method
# 'scheduling_method': 2 col_method
analysis_data_mem = pd.DataFrame(columns=[
'batch', 'date', 'name', 'index_B', 'index_T', 'index_S', 'index_Z',
'index_C', 'index_M', 'is_benchmark', 'is_discard', 'analysis_method',
'density', 'features', 'pca'
])
# index is path_date_name_BTSZCM_image
# all_features = pd.DataFrame(columns=['f' + str(col) for col in range(1, 257)])
# index is path_date_name_BTSZCM_image
# pca_coordinate = pd.DataFrame(columns=['pca' + str(col) for col in range(1, 3 + 1)])
# index is path_date_name_BTSZCM_image
# --- other vars ---
MAX_PYTHON_PROCESS = args.max_process
TIME_SLICE = args.time_slice
args_path = args.path
zoom = args.zoom
pca_sleep = 0
# ---the args.path IS existed? ---
print(
'Hello! Now this Program will do some Analysis of the Image that CD7 producing...'
)
if os.path.exists(args.path):
print('The Main Folder Path: ', args.path)
else:
exit('INPUT Folder Path does not existing!')
return False
# ---IS the experiment finished? ---
if args.name == '':
experiment_finished = True
else:
experiment_finished = False
# ---the path_date_name structures---
print('ALL the image files are here:')
path_date_name = scan_main_path(
args.path) # notice that the scan_main_path can disappear
this_number = 0
for this_name in path_date_name:
this_number += 1
print('>>>NO.', this_number, '>>>', this_name)
this_BTSCZM = CurrentFolderStructs(this_name)
dog = True
while dog:
this_BTSCZM.re_init_structs()
if this_BTSCZM.is_available:
print('B=', this_BTSCZM.current_B, 'T=', this_BTSCZM.current_T,
'S=', this_BTSCZM.current_S, 'Z=', this_BTSCZM.current_Z,
'C=', this_BTSCZM.current_C, 'M=', this_BTSCZM.current_M)
cardinal_mem.loc[this_name] = {
'scheduling_method': 0,
'experiment_complete': 0,
'exp_B': this_BTSCZM.current_B,
'exp_T': this_BTSCZM.current_T,
'exp_S': this_BTSCZM.current_S,
'exp_Z': this_BTSCZM.current_Z,
'exp_C': this_BTSCZM.current_C,
'exp_M': this_BTSCZM.current_M,
'analysis_complete': 0,
'ana_B': 0,
'ana_T': 0,
'ana_S': 0,
'ana_Z': 0,
'ana_C': 0,
'ana_M': 0
}
dog = False
else:
time.sleep(0.1)
# ---the cardinal.csv IS existed? it's structures? ---
cardinal_old_csv = pd.DataFrame()
if os.path.exists(os.path.join(args.path, 'Cardinal.csv')):
cardinal_old_csv = pd.read_csv(os.path.join(args.path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_old_csv = cardinal_old_csv.fillna(0)
cardinal_old_csv = cardinal_old_csv.applymap(lambda x: int(x))
if cardinal_old_csv.empty:
print('The First time to processing this Experiment!')
else:
print('Last time the processing STOP at here:')
print(cardinal_old_csv)
cardinal_mem[[
'scheduling_method', 'experiment_complete', 'analysis_complete',
'ana_B', 'ana_T', 'ana_S', 'ana_Z', 'ana_C', 'ana_M'
]] += cardinal_old_csv[[
'scheduling_method', 'experiment_complete', 'analysis_complete',
'ana_B', 'ana_T', 'ana_S', 'ana_Z', 'ana_C', 'ana_M'
]]
cardinal_mem = cardinal_mem.fillna(0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
# ---IS the experiment finished? ---
if experiment_finished:
print('The experiment complete! NOT real-time Processing...')
cardinal_mem['experiment_complete'] = 1
else:
this_F_index = os.path.join(args.path, args.date, args.name)
print('The experiment is processing! Real-time Processing!!!')
cardinal_mem['experiment_complete'] = 1
cardinal_mem.loc[this_F_index, 'experiment_complete'] = 0
cardinal_mem = cardinal_mem.fillna(0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
# ---copy last Cardinal_RTemp.csv to cardinal_mem---
if os.path.exists(os.path.join(args.path, 'Cardinal_RTemp.csv')):
cardinal_RTemp = pd.read_csv(os.path.join(args.path,
'Cardinal_RTemp.csv'),
header=0,
index_col=0)
this_F_index = cardinal_RTemp.iloc[0].name
cardinal_mem.loc[
this_F_index,
['ana_B', 'ana_T', 'ana_S', 'ana_Z', 'ana_C', 'ana_M'
]] = cardinal_RTemp.loc[
this_F_index,
['ana_B', 'ana_T', 'ana_S', 'ana_Z', 'ana_C', 'ana_M']]
os.remove(os.path.join(args.path, 'Cardinal_RTemp.csv'))
# ---cardinal_mem write to cardinal.csv ---
cardinal_mem.to_csv(path_or_buf=os.path.join(args.path, 'Cardinal.csv'))
print('The new structures is: ')
print(cardinal_mem)
# ---scheduling_method distribute ---
# 'args.method': 0: Not do Features analysis!
# 'args.method': 1: completed experiment using row method! (parallel execution)
# 'args.method': 3: always col (parallel execution)
# 'args.method': 4: always using col method and Sequential execution!
# 'args.method': 5: simple Sequential execution!
# 'scheduling_method': 0: no processing
# 'scheduling_method': 1: row_method
# 'scheduling_method': 2: col_method
if args.method == 1:
cardinal_mem.loc[(cardinal_mem['scheduling_method'] == 0) &
(cardinal_mem['experiment_complete'] == 1),
'scheduling_method'] = 1
cardinal_mem.loc[(cardinal_mem['scheduling_method'] == 0) &
(cardinal_mem['experiment_complete'] == 0),
'scheduling_method'] = 2
elif (args.method == 3) | (args.method == 4):
finished_exp_count = \
cardinal_mem.loc[(cardinal_mem['scheduling_method'] == 2) & (cardinal_mem['analysis_complete'] == 1)].shape[
0]
processing_exp_count = \
cardinal_mem.loc[(cardinal_mem['scheduling_method'] == 2) & (cardinal_mem['analysis_complete'] == 0)].shape[
0]
unstart_exp_count = \
cardinal_mem.loc[(cardinal_mem['scheduling_method'] == 0) & (cardinal_mem['analysis_complete'] == 0)].shape[
0]
error_exp_count = cardinal_mem.loc[cardinal_mem['scheduling_method'] ==
1].shape[0]
print('method 3/4 finished_exp_count:', finished_exp_count)
print('method 3/4 processing_exp_count:', processing_exp_count)
print('method 3/4 unstart_exp_count:', unstart_exp_count)
print('method 3/4 error_exp_count:', error_exp_count)
if processing_exp_count > 1 or error_exp_count > 0:
print('Method 3/4 ERROR! Wrong using method 3/4!')
exit('Method 3/4 ERROR! Wrong using method 3/4!')
return False
# ---the Analysis_Data.csv IS existed? or create it ---
if os.path.exists(os.path.join(args.path, 'Analysis_Data.csv')):
# analysis_data_mem = pd.read_csv(os.path.join(args.path, 'Analysis_Data.csv'), header=0, index_col=0)
print('The Analysis_Data.csv is existed!')
else:
print('The Analysis_Data.csv does NOT existed!')
analysis_data_mem.to_csv(
path_or_buf=os.path.join(args.path, 'Analysis_Data.csv'))
# # --- the Features.csv IS existed? or create it ---
# if os.path.exists(os.path.join(args.path, 'Features.csv')):
# # all_features = pd.read_csv(os.path.join(args.path, 'Features.csv'), header=0, index_col=0)
# print('The Features.csv is existed!')
# else:
# print('The Features.csv does NOT existed!')
# all_features.to_csv(path_or_buf=os.path.join(args.path, 'Features.csv'))
# --- the PCA.csv IS existed? or create it ---
# if os.path.exists(os.path.join(args.path, 'PCA.csv')):
# # pca_coordinate = pd.read_csv(os.path.join(args.path, 'PCA.csv'), header=0, index_col=0)
# pca_sleep = 0
# print('The PCA.csv is existed!')
# else:
# pca_sleep = 30
# print('The PCA.csv does NOT existed!')
# pca_coordinate.to_csv(path_or_buf=os.path.join(args.path, 'PCA.csv'))
# # # do some PCA analysis
# ---the AVG_Density.csv IS existed? or create it ---
# if os.path.exists(os.path.join(args.path, 'AVG_Density.csv')):
# print('The AVG_Density.csv is existed!')
# # avg_density_mem = pd.read_csv(os.path.join(args.path, 'AVG_Density.csv'), header=0, index_col=0)
# else:
# print('The AVG_Density.csv does NOT existed!')
# avg_density_mem = pd.DataFrame(columns=['S' + str(col) for col in range(1, args.S + 1)])
# avg_density_mem.to_csv(path_or_buf=os.path.join(args.path, 'AVG_Density.csv'))
# ---the experiment plan Experiment_Plan.csv IS existed? (including the IPS_density, CHIR and time)---
experiment_plan_csv = pd.DataFrame()
if os.path.exists(os.path.join(args.path, 'Experiment_Plan.csv')):
experiment_plan_csv = pd.read_csv(os.path.join(args.path,
'Experiment_Plan.csv'),
header=0,
index_col=0)
if experiment_plan_csv.empty:
print('The Experiment Plan is EMPTY!!!')
else:
print('The Experiment Plan is:')
print(experiment_plan_csv)
# ---the saved Benchmark IS existed? ---
benchmark = pd.DataFrame()
if os.path.exists(os.path.join(args.path, 'Benchmark.csv')):
benchmark = pd.read_csv(os.path.join(args.path, 'Benchmark.csv'),
header=0,
index_col=0)
if benchmark.empty:
print('NO Benchmark file!!! De Novo Developmental Trajectory')
else:
print('the Benchmark Developmental Trajectory: ')
# do some Benchmark PCA
# ---this processing experiment ---
if not experiment_finished:
print('The experiment design :::')
print('total Block ::: ', args.B)
print('total Time ::: ', args.T)
print('total Scene ::: ', args.S)
print('total Z-direction ::: ', args.Z)
print('total Channel ::: ', args.C)
print('total Mosaic tiles ::: ', args.M)
# --- What is the edge of the disc? ---
tiles_margin = scan_dish_margin(args.path)
print('The photograph\'s edge is :', tiles_margin)
# --- make dir: figure to save PCA figures ---
# if not os.path.exists(os.path.join(args.path, 'Figure')):
# os.makedirs(os.path.join(args.path, 'Figure'))
# print('All the figures result is in : ', os.path.join(args.path, 'Figure'))
# --- make dir: all the stitching images S01-S96 ---
zoom_str = "%.0f%%" % (args.zoom * 100)
# if not os.path.exists(os.path.join(args.path, 'SSS_' + zoom_str)): # SSS stand for Sequential Stitching Scene
# os.makedirs(os.path.join(args.path, 'SSS_' + zoom_str))
# for i in range(1, args.S + 1):
# if not os.path.exists(os.path.join(args.path, 'SSS_' + zoom_str, 'S' + str(i))):
# os.makedirs(os.path.join(args.path, 'SSS_' + zoom_str, 'S' + str(i)))
print('Stitching Scene zoom is: ', zoom_str)
print('Sequential Stitching Scene is in : ',
os.path.join(args.path, 'SSS_' + zoom_str))
# --- make dir: useful stitching images S01-S96 ---
# if not os.path.exists(
# os.path.join(args.path, 'SSSS_' + zoom_str)): # SSSS stand for Square Sequential Stitching Scene
# os.makedirs(os.path.join(args.path, 'SSSS_' + zoom_str))
# for i in range(1, args.S + 1):
# if not os.path.exists(os.path.join(args.path, 'SSSS_' + zoom_str, 'S' + str(i))):
# os.makedirs(os.path.join(args.path, 'SSSS_' + zoom_str, 'S' + str(i)))
print('Stitching Scene zoom is: ', zoom_str)
print('Square Sequential Stitching Scene is in : ',
os.path.join(args.path, 'SSSS_' + zoom_str))
# ------ Initialization finished ------
print('Initialization finished!',
'Now you are past the point of no return!')
print('\n---------------------------------\n')
# ------------ begin ------------
# 'args.method': 0: Not do Features analysis!
# 'args.method': 1: completed experiment using row method! (parallel execution)
# 'args.method': 3: always col (parallel execution)
# 'args.method': 4: always using col method and Sequential execution!
# 'args.method': 5: simple Sequential execution!
# col means: finish an experiment.czexp one by one, once it handel only one czexp
# row means: do several experiment.czexp at one time, so once it handel several czexps
if args.method == 0:
print('Not do Features analysis!')
print('Exit Features analysis ... ')
elif args.method == 1:
print(
'method 1 : completed experiment using row method! (parallel execution)'
)
os.system(
"start /min python Scheduling_2Directions.py --main_path {} --B {} --T {} --S {} --Z {} --C {} --M {} --rt_process {} --once_process {} --max_process {} --time_slice {}"
.format(args.path, args.B, args.T, args.S, args.Z, args.C, args.M,
int(2 * MAX_PYTHON_PROCESS / 3),
int(MAX_PYTHON_PROCESS / 3),
int(2 * MAX_PYTHON_PROCESS / 3), TIME_SLICE))
elif args.method == 2:
print('method 2 : Nothing!')
elif args.method == 3:
print('method 3 : always using col method! (parallel execution) ')
os.system(
"start /min python Scheduling_Column.py --main_path {} --B {} --T {} --S {} --Z {} --C {} --M {} --max_process {} --time_slice {}"
.format(args.path, args.B, args.T, args.S, args.Z, args.C, args.M,
MAX_PYTHON_PROCESS, TIME_SLICE))
elif args.method == 4:
print('method 4 : always using col method and Sequential execution!')
os.system(
"start /min python Scheduling_Sequential.py --main_path {} --B {} --T {} --S {} --Z {} --C {} --M {} --max_process {} --time_slice {} --zoom {} --overlap {} --silly {}"
.format(args.path, args.B, args.T, args.S, args.Z, args.C, args.M,
MAX_PYTHON_PROCESS, TIME_SLICE, zoom, args.overlap,
args.missing))
elif args.method == 5:
print('method 5 : simple Sequential execution!')
os.system(
"start /min python Scheduling_x.py --main_path {} --B {} --T {} --S {} --Z {} --C {} --M {} --max_process {} --time_slice {} --zoom {} --overlap {} --analysis {}"
.format(args.path, args.B, args.T, args.S, args.Z, args.C, args.M,
MAX_PYTHON_PROCESS, TIME_SLICE, zoom, args.overlap,
args.analysis))
else:
print('key method should be: 1:row Catching up or 3:always col!')
print('Exit...')
# ------ begin pca analysis ------
if args.pca == 0:
print('Not do PCA analysis!')
print('Exit PCA analysis ...')
elif args.pca == 1:
print('PCA method 1 : Always analysis the last!')
time.sleep(pca_sleep)
watchdog_pca = True
while watchdog_pca:
print(cacu_draw_save_pca(args.path))
time.sleep(15)
elif args.pca == 2:
print('PCA method 2 : Catching up way!')
os.system(
"start python Task_Draw_PCA.py --main_path {} --exp_finished {} --step {}"
.format(args.path, experiment_finished, 10))
else:
print(
'Whether do pca analysis? 0:Not; 1:Always analysis the last; 2: Catching up way'
)
print('Exit...')
# ------ begin others analysis ------
time.sleep(30)
def main(args):
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
pd.set_option('max_colwidth', 100)
pd.set_option('display.width', None)
global main_path, tiles_margin, cardinal_mem, image_file_type, zoom, overlap, TIME_SLICE, do_analysis, MAX_PYTHON_process_number
main_path = args.main_path
tiles_margin = scan_dish_margin(main_path)
image_file_type = ('.jpg', '.png', '.tif')
# zomm = args.zoom
zoom = [
1
] # be a float or a list, the first number is the processing pic zoom size,the rest is only store
# square_side = 5
overlap = args.overlap
# Density_Alarm = 0
MAX_PYTHON_process_number = args.max_process
TIME_SLICE = args.time_slice
do_analysis = args.analysis
# matrix_list = return_96well_30_Tiles()
cardinal_mem = pd.read_csv(os.path.join(main_path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_mem = cardinal_mem.fillna(0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
print('Hello I am the Scheduling_X.py program! Now I will sleep 5s!')
time.sleep(5)
print('Scheduling_Sequential.py is initialized! And the Cardinal.csv is:')
print(cardinal_mem)
for this_index, this_row in cardinal_mem.iterrows():
if this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 1:
print(this_index, 'Analysis Complete!!!')
next
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Catching up Analysising!!!')
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 0:
print(this_index, 'Real Time Analysising!!!')
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to Catching up!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 0 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to real time Analysising!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
else:
print('Method 5 ERROR! Wrong using method 5!')
time.sleep(30)
exit('Method 5 ERROR! Wrong using method 5!')
print('Mission Complete!!! Now return in 30 seconds!')
time.sleep(30)
def main(args):
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)
pd.set_option('max_colwidth', 100)
pd.set_option('display.width', None)
print(
'Hello I am the Scheduling_Sequential.py program! Now I will sleep 5s!'
)
time.sleep(5)
global main_path, tiles_margin, cardinal_mem, MAX_PYTHON_process_number, TIME_SLICE, image_file_type, square_side, zoom, overlap, silly, Density_Alarm, density_avg_base_list
main_path = args.main_path
tiles_margin = scan_dish_margin(main_path)
cardinal_mem = pd.read_csv(os.path.join(main_path, 'Cardinal.csv'),
header=0,
index_col=0)
cardinal_mem = cardinal_mem.fillna(0)
cardinal_mem = cardinal_mem.applymap(lambda x: int(x))
# scene_density_mem = pd.read_csv(os.path.join(main_path, 'Scene_Density.csv'), header=0, index_col=0)
MAX_PYTHON_process_number = args.max_process
TIME_SLICE = args.time_slice
image_file_type = ('.jpg', '.png', '.tif')
square_side = 5
zoom = [args.zoom, 0.3]
# zoom can be a float or a list, the first number is the processing pic zoom size,the rest is only store
overlap = args.overlap
silly = args.silly
Density_Alarm = 0
density_avg_base_list = []
print('Scheduling_Sequential.py is initialized! And the Cardinal.csv is:')
print(cardinal_mem)
for this_index, this_row in cardinal_mem.iterrows():
if this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 1:
print(this_index, 'Analysis Complete!!!')
next
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Catching up Analysising!!!')
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 2 and this_row[
'experiment_complete'] == 0:
print(this_index, 'Real Time Analysising!!!')
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
# print('Mission Complete!!!')
# return True
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 1 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to Catching up!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_scheduling(this_index, args.B, args.T, args.S, args.Z, args.C,
args.M)
elif this_row['scheduling_method'] == 0 and this_row[
'experiment_complete'] == 0 and this_row[
'analysis_complete'] == 0:
print(this_index, 'Waiting to real time Analysising!!!')
cardinal_mem.loc[this_index, 'scheduling_method'] = 2
cardinal_mem.to_csv(
path_or_buf=os.path.join(main_path, 'Cardinal.csv'))
m3_rt(this_index, args.B, args.T, args.S, args.Z, args.C, args.M)
# print('Mission Complete!!!')
# return True
else:
print('Method 4 ERROR! Wrong using method 4!')
time.sleep(30)
exit('Method 4 ERROR! Wrong using method 4!')
print('Mission Complete!!!')
time.sleep(30)