def on_btn_save_udf_param_clicked(self):
"""
Slot documentation goes here.
"""
msg = u'保存参数并同时更新UDF中建筑负载文件名，确定吗?'
reply = self.show_yesno_msgbox(msg)
if reply == 0:
return
fname = self.le_fluent_udf_file.text()
if fname == '':
msg = u'UDF文件名为空, 请先设置一个有效的UDF文件'
self._show_tips(msg, tip_type=1)
return
# check if file path exists
if not os.path.exists(fname):
msg = u'UDF文件路径不存在, 请打开一个有效的UDF文件!'
self._show_tips(msg, tip_type=1)
return
# first, get params from widgets
params = self.get_udf_param_from_widgets()
# read the load file
progress_dlg = QProgressDialog(self)
progress_dlg.setModal(True)
progress_dlg.setMinimumDuration(1)
progress_dlg.setWindowTitle(u"处理数据")
progress_dlg.setLabelText(u"正在处理建筑负荷数据...")
progress_dlg.setCancelButtonText("Cancel")
# we don't know how many lines in the load file
progress_dlg.setMinimum(1)
progress_dlg.setMaximum(10000)
max_q = 0.0
min_q = 0.0
line_cnt = 0
with open(params['load_file'], 'r') as rfh:
for line in rfh:
val = float(line)
if val > max_q:
max_q = val
if val < min_q:
min_q = val
progress_dlg.setValue(line_cnt)
if progress_dlg.wasCanceled():
return
line_cnt += 1
# set the max value to terminate the progress dialog
if line_cnt < 10000:
QThread.sleep(1)
progress_dlg.setValue(10000)
params['copc_max_q'] = max_q
params['coph_max_q'] = min_q
# modify the udf file
result = self.udf_model.write_params(params, fname)
if result == True:
msg = u'文件%s更新成功' % fname
self._show_tips(msg)
else:
msg = u'文件更新失败, 请确保%s是有效的UDF文件' % fname
self._show_tips(msg, tip_type=1)
def run(self):
num = len(self.servers)
for self.servers_index in range(num):
self.files_index = 0
self.ftp.connectToHost(self.servers[self.servers_index]["host"], int(self.servers[self.servers_index]["port"]))
self.uploading = True
while self.uploading:
QThread.sleep(1)
self.information.emit(u"<font color=green>所有服务器上传完成。成功：%s 失败：%s</font><br />" % (self.succeed, num - self.succeed))
def run(self):
num = len(self.servers)
for self.servers_index in range(num):
self.files_index = 0
self.ftp.connectToHost(
self.servers[self.servers_index]["host"],
int(self.servers[self.servers_index]["port"]))
self.uploading = True
while self.uploading:
QThread.sleep(1)
self.information.emit(
u"<font color=green>所有服务器上传完成。成功：%s 失败：%s</font><br />" %
(self.succeed, num - self.succeed))
def new_project(self):
# Support '.raftdb' file types
file = QFileDialog.getSaveFileName(None, "Create new RAFT DB file", "", "RAFT Database File (*.raftdb)")
if file:
self.Progress.show()
try:
# Reinitialize with the database value set from new db name
self.framework.closeDB()
# 2 seconds to settle
QThread.sleep(2)
self.db = str(file)
self.databaseThread.connectDb(self.db, self)
finally:
self.Progress.close()
def run(self):
nTries = 0
while nTries < self.NUMBER_OF_TRIES:
if nTries > 0:
self.target.seek(0)
QThread.sleep(self.TIMEOUT)
nTries += 1
#try standard first (with proxy if environment variable is set)
try:
if not self._no_proxy:
try:
hdr = {'User-Agent': 'Mozilla/5.0', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8'}
req = urllib2.Request(self.url.encode('utf-8'), headers=hdr)
with contextlib.closing(urllib2.urlopen(req)) as u:
self._readData(u)
break
except urllib2.URLError:
#very likely a proxy error
self.logger.debug("Downloading %s failed, forcing without proxy now", self.url)
#try again without proxy
req2 = urllib2.Request(self.url.encode('utf-8'), headers=hdr)
proxy_handler = urllib2.ProxyHandler({})
no_proxy_opener = urllib2.build_opener(proxy_handler)
with contextlib.closing(no_proxy_opener.open(req2)) as n_u:
self._readData(n_u)
# finished
break
except HTTPError as e:
# don't print trace on HTTP error
self.logger.warning("Error while downloading %s (%s)", self.url, e)
if nTries >= self.NUMBER_OF_TRIES or e.code == 404:
self.error.emit(self, formatException())
if e.code == 404:
# no need to retry
break
except:
self.logger.warning("Error while downloading %s", self.url)
self.error.emit(self, formatException())
break
def save_as(self):
""" Dialog and logic to save the temp.raftdb file to a working database """
# Support '.db' file types
file = QFileDialog.getSaveFileName(None, "Save to RAFT DB file", "", "RAFT Database File (*.raftdb)")
if file:
self.Progress.show()
try:
# Reinitialize with the database value set from new db name
self.framework.closeDB()
# 5 seconds to settle
QThread.sleep(2)
# New db location
new_db = str(file)
shutil.move(self.db, new_db)
self.db = new_db
self.databaseThread.connectDb(self.db, self)
finally:
self.Progress.close()
def umount(self, device_folder, device, thread_object):
"""
Unmount device
Arguments:
device_folder - Mount point folder
device - Device name
thread_object - Thread object that is connected to the mount point
Return:
None
"""
if 'hdd' in device_folder or 'HDD' in device_folder:
mount_folder = '{0}/{1}/{2}'.format(self.mount_directory,
device_folder, device)
else:
mount_folder = '{0}/{1}'.format(self.mount_directory,
device_folder)
if not self._check_existence(mount_folder):
try:
os.rmdir(mount_folder)
except OSError:
self.sig_info.emit('\n'.join([
'{0} is not accessable!'.format(mount_folder),
'The computer might need to be restarted!',
'Please contact your system administrator!'
]))
else:
self.sig_info.emit('First mount {0}'.format(mount_folder))
return None
self.abort_finished = False
if thread_object is None:
pass
elif thread_object.running:
thread_object.kill_thread = True
while not self.abort_finished:
QThread.sleep(1)
thread_object.kill_thread = False
else:
pass
self.abort_finished = False
cmd = 'sudo -S -k umount {0}'.format(mount_folder)
idx, value = self._start_process(cmd)
if 'mount error' in value:
self.sig_info.emit('Could not umount {0}: {1}'.format(
mount_folder, value))
elif idx == 1:
self.sig_info.emit('Could not umount {0}: {1}'.format(
mount_folder, value))
elif 'hdd_test' in mount_folder:
os.rmdir(mount_folder)
else:
try:
os.rmdir(mount_folder)
except OSError:
if self.password:
self.sig_info.emit('Could not umount {0}: {1}'.format(
mount_folder,
value.replace(self.password, 'SUDOPASSWORD')))
else:
self.sig_info.emit('Could not umount {0}: {1}'.format(
mount_folder, value))
return
device = device.split('/')[-1]
self.sig_success.emit('Not connected', device, 'purple')
with open(self.save_files[device], 'w') as write:
write.write('')
if device_folder == 'HDD':
hdd_folder = '{0}/{1}'.format(self.mount_directory,
device_folder)
if not os.listdir(hdd_folder):
os.rmdir(hdd_folder)
self.refresh_quota()
def run(self):
self.appendToOutput("Test 1 Start.\n");
QThread.sleep(10); #sleep for 10 seconds
self.appendToOutput("Test 1 End.\n");
def run(self, settings):
"""
Start the process.
Arguments:
settings - Transphire settings
Return:
None
"""
# Set settings
self.settings = settings
content_process = cp.deepcopy(self.content_process)
# Set stop variable to the return value of the pre_check
self.stop = bool(self.pre_check_programs())
# Set paths
self.settings['stack_folder'] = os.path.join(
self.settings['project_folder'], 'Stack')
self.settings['meta_folder'] = os.path.join(
self.settings['project_folder'], 'Meta')
self.settings['software_meta_folder'] = os.path.join(
self.settings['project_folder'], 'Software_meta')
self.settings['motion_folder'] = os.path.join(
self.settings['motion_folder'],
self.settings['Copy']['Motion'].replace(' ', '_'))
self.settings['ctf_folder'] = os.path.join(
self.settings['ctf_folder'],
self.settings['Copy']['CTF'].replace(' ', '_'))
self.settings['scratch_motion_folder'] = os.path.join(
self.settings['scratch_folder'],
self.settings['Copy']['Motion'].replace(' ', '_'))
self.settings['compress_folder'] = os.path.join(
self.settings['compress_folder'], 'Compress')
self.settings['Copy_hdd_folder'] = os.path.join(
self.settings['Copy_hdd_folder'], 'HDD')
self.settings['Copy_work_folder'] = os.path.join(
self.settings['Copy_work_folder'],
self.settings['Copy']['Copy to work'].replace(' ', '_'))
self.settings['Copy_backup_folder'] = os.path.join(
self.settings['Copy_backup_folder'],
self.settings['Copy']['Copy to backup'].replace(' ', '_'))
# Set CTF settings
self.settings['CTF_folder'] = {}
for entry in self.settings['Copy']['CTF_entries']:
self.settings['CTF_folder'][entry] = os.path.join(
self.settings['project_folder'], entry.replace(' ', '_'))
self.sig_plot_ctf.emit(entry, self.settings['CTF_folder'][entry],
self.settings)
# Set Motion settings
self.settings['Motion_folder'] = {}
for entry in self.settings['Copy']['Motion_entries']:
self.settings['Motion_folder'][entry] = os.path.join(
self.settings['project_folder'], entry.replace(' ', '_'))
self.sig_plot_motion.emit(entry,
self.settings['Motion_folder'][entry],
self.settings)
# Set default values for folder list and thread list
folder_list = ['stack_folder', 'meta_folder']
use_threads_list = ['Meta', 'Find', 'Copy']
# Fill folder list and threads list
for name in ['work', 'backup']:
short_name = 'Copy_{0}'.format(name)
long_name = 'Copy to {0}'.format(name)
folder_name = '{0}_folder'.format(short_name)
user_name = '{0}_user'.format(short_name)
self.settings['Copy'][short_name] = \
self.settings['Copy'][long_name]
if self.settings['Copy'][long_name] != 'False':
if self.settings['Copy'][long_name] == 'Later':
pass
elif not os.path.ismount(self.settings[folder_name]):
try:
os.listdir(self.settings[folder_name])
except PermissionError:
pass
except FileNotFoundError:
self.sig_error.emit(
'{0} folder {1} not mounted!'.format(
name, self.settings['Copy'][long_name]))
self.sig_finished.emit()
return None
except OSError as err:
if 'Required key' in str(err):
self.sig_error.emit('\n'.join([
'{0} folder {1} no longer mounted! '.format(
name, self.settings['Copy'][long_name]),
'Use kinit to refresh the key'
]))
self.sig_finished.emit()
return None
else:
print('\n'.join([
'Unknown Error occured!',
'Please contact the TranSPHIRE authors!'
]))
raise
else:
self.sig_error.emit(
'{0} folder {1} not mounted!'.format(
name, self.settings['Copy'][long_name]))
self.sig_finished.emit()
return None
else:
pass
try:
self.settings[user_name] = self.settings['user_{0}'.format(
self.settings['Copy'][long_name].replace(' ', '_'))]
except KeyError:
self.sig_error.emit('{0} needs remount! '.format(name))
self.sig_finished.emit()
return None
use_threads_list.append(short_name)
else:
pass
# Decide if one will use copy to HDD
self.settings['Copy']['Copy_hdd'] = self.settings['Copy'][
'Copy to HDD']
if self.settings['Copy']['Copy to HDD'] != 'False':
if self.settings['Copy']['Copy to HDD'] == 'Later':
pass
else:
try:
for folder in glob.glob('{0}/*'.format(
self.settings['Copy_hdd_folder'])):
if not os.path.ismount(folder):
try:
os.listdir(folder)
except PermissionError:
pass
else:
self.sig_error.emit(
'HDD not mounted or not well unmounted!' +
'Please remount if you want to use HDD')
self.sig_finished.emit()
return None
else:
pass
except FileNotFoundError:
self.sig_error.emit(
'HDD not mounted or not well unmounted!' +
'Please remount if you want to use HDD!')
self.sig_finished.emit()
return None
use_threads_list.append('Copy_hdd')
else:
pass
# Set CTF settings
if self.settings['Copy']['CTF'] != 'False':
folder_list.append('ctf_folder')
use_threads_list.append('CTF')
ctf_name = self.settings['Copy']['CTF']
try:
if self.settings[ctf_name]['Use movies'] == 'True':
self.settings['Copy']['CTF_frames'] = 'True'
self.settings['Copy']['CTF_sum'] = 'False'
else:
self.settings['Copy']['CTF_frames'] = 'False'
self.settings['Copy']['CTF_sum'] = 'True'
except KeyError:
self.settings['Copy']['CTF_frames'] = 'False'
self.settings['Copy']['CTF_sum'] = 'True'
else:
self.settings['Copy']['CTF_frames'] = 'False'
self.settings['Copy']['CTF_sum'] = 'False'
# Set Compress settings
if self.settings['Copy']['Compress data'] != 'False':
folder_list.append('compress_folder')
use_threads_list.append('Compress')
else:
pass
# Set Motion settings
if self.settings['Copy']['Motion'] != 'False':
folder_list.append('motion_folder')
use_threads_list.append('Motion')
else:
pass
# Create output directories
for entry in folder_list:
try:
tu.mkdir_p(self.settings[entry])
except PermissionError:
continue
except OSError as err:
print(str(err))
self.sig_error.emit(str(err))
self.sig_finished.emit()
return None
# Queue communication dictionary
queue_com = {
'status': qu.Queue(),
'notification': qu.Queue(),
'error': qu.Queue(),
'plot_ctf': qu.Queue(),
'plot_motion': qu.Queue()
}
# Fill different dictionarys with process information
typ_dict = {}
wait_dict = {}
share_dict = {}
bad_dict = {}
queue_dict = {}
full_content = []
idx_number = 0
idx_values = 1
for entry in content_process:
for process in entry:
for key in process:
process[key][idx_values]['group'], process[key][idx_values]['aim'] = \
process[key][idx_values]['group'].split(';')
process[key][idx_values]['aim'] = process[key][idx_values][
'aim'].split(',')
wait_dict[key] = False
share_dict[key] = []
bad_dict[key] = []
queue_dict[key] = qu.Queue()
typ_dict[key] = {
'file_number':
0,
'spot':
False,
'lost_input_meta':
False,
'lost_input_frames':
False,
'lost_work':
False,
'lost_backup':
False,
'lost_hdd':
False,
'full_transphire':
False,
'full_work':
False,
'full_backup':
False,
'full_hdd':
False,
'unknown_error':
False,
'queue_lock':
QMutex(),
'save_lock':
QMutex(),
'count_lock':
QMutex(),
'error_lock':
QMutex(),
'bad_lock':
QMutex(),
'share_lock':
QMutex(),
'spot_dict':
self.fill_spot_dict(),
'number_file':
'{0}/last_filenumber.txt'.format(
self.settings['project_folder']),
'save_file':
'{0}/Queue_{1}'.format(self.settings['queue_folder'],
key),
'done_file':
'{0}/Queue_{1}_done'.format(
self.settings['queue_folder'], key),
'error_file':
'{0}/Queue_{1}_error'.format(
self.settings['error_folder'], key),
}
if process[key][idx_number] == '1':
full_content.append([key, process[key]])
else:
for idx in range(int(process[key][idx_number])):
full_content.append(
['{0}_{1}'.format(key, idx + 1), process[key]])
# Shared dictionary
shared_dict = {
'share': share_dict,
'bad': bad_dict,
'queue': queue_dict,
'translate_lock': QMutex(),
'ctf_star_lock': QMutex(),
'ctf_partres_lock': QMutex(),
'global_lock': QMutex(),
'typ': typ_dict
}
# Fill process queues
for entry in content_process:
for process in entry:
for key in process:
self.prefill_queue(shared_dict=shared_dict,
entry=process[key][1])
# Define file number and check if file already exists
shared_dict['typ']['Copy']['file_number'] = int(
self.settings['General']['Start number']) - 1
if self.settings['General']['Rename micrographs'] == 'True':
new_name = '{0}/{1}{2:0{3}d}{4}'.format(
self.settings['meta_folder'],
self.settings['General']['Rename prefix'],
shared_dict['typ']['Copy']['file_number'] + 1,
len(self.settings['General']['Estimated mic number']),
self.settings['General']['Rename suffix'])
if os.path.exists('{0}.jpg'.format(new_name)):
self.stop = True
try:
with open(shared_dict['typ']['Copy']['number_file'],
'r') as read:
shared_dict['typ']['Copy']['file_number'] = int(
read.readline())
except FileNotFoundError:
shared_dict['typ']['Copy']['file_number'] = int(
self.settings['General']['Start number'])
message = '{0}: File {1} already exists!\n'.format(
'Copy',
new_name
) + \
'Check Startnumber!'
queue_com['error'].put(message)
queue_com['notification'].put(message)
else:
pass
else:
pass
# Start threads
thread_list = []
use_threads_set = set(use_threads_list)
for key, settings_content in full_content:
content_settings = settings_content[idx_values]
thread = ProcessThread(shared_dict=shared_dict,
name=key,
content_settings=content_settings,
queue_com=queue_com,
settings=self.settings,
mount_directory=self.mount_directory,
password=self.password,
use_threads_set=use_threads_set,
stop=self.stop,
parent=self)
thread.start()
thread_list.append([thread, key, content_settings])
QThread.sleep(1)
# Run until the user stops the processes
go_on = True
while go_on:
try:
self.check_queue(queue_com=queue_com)
except BrokenPipeError:
pass
if self.stop:
go_on = False
else:
pass
QThread.sleep(3)
# Indicate to stop all processes
for key, settings_content in full_content:
typ = settings_content[idx_values]['name']
size = shared_dict['queue'][typ].qsize()
self.sig_status.emit(
'Stopping {0} {1}'.format(
size, shared_dict['typ'][typ]['file_number']), key, 'red')
# Send the stop signals to all threads
for thread, name, setting in thread_list:
thread.stop = True
# Wait for all threads to finish
for thread, name, setting in thread_list:
typ = setting['name']
thread.quit()
thread.wait()
self.check_queue(queue_com=queue_com)
size = shared_dict['queue'][typ].qsize()
self.sig_status.emit(
'Not running {0} {1}'.format(
size, shared_dict['typ'][typ]['file_number']), name,
'purple')
self.sig_finished.emit()
def foo(self, i, s):
for _ in range(3):
QThread.sleep(1)
print i, str(s.toUtf8()).encode('utf-8').strip(), threading.currentThread().ident
