diff --git a/Jenkinsfile b/Jenkinsfile index a62f438429..36a9b1e2b4 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -231,7 +231,7 @@ def isSkipStage() { // 'deploy', // 'test-continuous' ] - return stages.contains(STAGE_NAME) + return stages.contains(STAGE_NAME) || AGENT_OS_NAME == "win" } pipeline { diff --git a/libpyEM/EMAN2.py b/libpyEM/EMAN2.py index 641bb47adb..5a2a861906 100644 --- a/libpyEM/EMAN2.py +++ b/libpyEM/EMAN2.py @@ -60,6 +60,14 @@ HOMEDB=None +try: + from pyStarDB import sp_pystardb as star +except ImportError: + print("pyStarDB package is required in to use star files with EMData object") + +import pandas as pd +import numpy as np + # This next line is to initialize the Transform object for threadsafety. Utterly stupid approach, but a functional hack T=Transform({"type":"2d","alpha":0}) @@ -81,7 +89,7 @@ # behavior appropriately #try: #import EMAN2db -from EMAN2db import EMAN2DB,db_open_dict,db_close_dict,db_remove_dict,db_list_dicts,db_check_dict,db_parse_path,db_convert_path,db_get_image_info,e2gethome, e2getcwd +from EMAN2db import EMAN2DB,db_open_dict,db_close_dict,db_remove_dict,db_list_dicts,db_check_dict,db_parse_path,db_convert_path,db_get_image_info,e2gethome, e2getcwd, db_set_header_star, db_em_to_star_header from EMAN2jsondb import JSDict,js_open_dict,js_close_dict,js_remove_dict,js_list_dicts,js_check_dict,js_one_key #except: # HOMEDB=None @@ -2683,6 +2691,42 @@ def db_read_image(self, fsp, *parms, **kparms): #if lsxcache==None or lsxcache.path!=fsp: lsxcache=LSXFile(fsp,True) #return lsxcache.read_image(parms[0]) + if fsp.endswith('.star'): + star_file = star.StarFile(fsp) + import_header = False + try: + data = star_file['particles'] + except: + data = star_file[''] + try: + if parms[2] == True: # for retrun starfileclass (for header only) + return star_file + except IndexError: + pass + try: + if parms[1] == True: # for return header in EMData object + import_header = True + except IndexError: + pass + # if no index value is passed then read at index 0, otherwise read at specified index by parms + if len(parms) == 0 : + parms = list() + parms.append(0) + elif len(parms) > 0 : + parms = list(parms) + else: + assert False, 'Unreachable code' + + numbers = int(data.iloc[parms[0]]['_rlnImageName'].split('@')[0]) + filename = data.iloc[parms[0]]['_rlnImageName'].split('@')[1] + if import_header == False: # if returning an EMData object with header + images + self.read_image_c(filename, (int(numbers)-1), **kparms) + else: + self.read_image_c(filename, (int(numbers)-1), True) + db_set_header_star(self, data.iloc[parms[0]], star_file) + self.update() + return + if len(kparms) != 0: if 'img_index' not in kparms: kparms['img_index'] = 0 @@ -2733,6 +2777,37 @@ def db_read_images(fsp, *parms): #if lsxcache==None or lsxcache.path!=fsp: lsxcache=LSXFile(fsp,True) #return lsxcache.read_images(*parms) + if fsp.endswith('.star'): + star_file = star.StarFile(fsp) + import_header = False + try: + data = star_file['particles'] + except KeyError: + data = star_file[''] + try: + if parms[2] == True: # for returning starfile class (for header only) + return star_file + except IndexError: + pass + try: + if parms[1] == True: + import_header = True + except IndexError: + pass + # if no index value is passed then read everything, otherwie read images from list no's + if len(parms) > 0: + image_data = data.iloc[parms[0]] + elif len(parms) == 0: + image_data = data + else: + pass + total_imgs = [] + for index in range(image_data.shape[0]): + img = EMData() + img.read_image(fsp, parms[0][index], import_header) + total_imgs.append(img) + return total_imgs + if len(parms) > 0 and (parms[0] == None or len(parms[0]) == 0): parms = (list(range(EMUtil.get_image_count(fsp))),) + parms[1:] return EMData.read_images_c(fsp, *parms) @@ -2774,12 +2849,45 @@ def db_write_image(self, fsp, *parms): db.set(self, key=key, region=region, txn=None) # this makes region writing work # db[parms[0]] = self # this means region writing does not work return + elif fsp.endswith('.star'): + # if no index value is passed then write at index 0, otherwise write at index specified by parms + if len(parms) == 0: + parms = [0] + else: + pass + if isinstance(self, list): + pass + else: + self = [self] + db_write_images(self, fsp, parms) + return return self.write_image_c(fsp, *parms) EMData.write_image_c = EMData.write_image EMData.write_image = db_write_image +def db_write_images(EM_data_list, fsp, indices): + local_bdb_stack = db_open_dict(fsp) + special_keys = star.StarFile(fsp).special_keys + ignored_keys = star.StarFile(fsp).ignored_keys + try: + local_bdb_stack.star['particles'] + except: + local_bdb_stack.star.update('particles', pd.DataFrame(), True) + + for loc_part_id, loc_part_value in enumerate(indices): + particle_img_dict = EM_data_list[loc_part_id].get_attr_dict() + particle_img_dict["ptcl_source_coord_id"] = loc_part_value + particle_img_dict['data_path'] = fsp.split('.star')[0] + '.mrcs' + db_em_to_star_header(particle_img_dict, local_bdb_stack.star['particles'], loc_part_value, special_keys, ignored_keys) + EM_data_list[loc_part_id].write_image_c(particle_img_dict['data_path'], loc_part_value) + + local_bdb_stack.star.write_star_file(out_star_file=fsp, overwrite=True) + db_close_dict(fsp) + +EMData.write_images = staticmethod(db_write_images) + def im_write_compressed(self,fsp,n,bits=8,minval=0,maxval=0,nooutliers=False,level=1,erase=False): """write_compressed(self or list,fsp,n,bits=8,minval=0,maxval=0,nooutliers=False,level=1) diff --git a/libpyEM/EMAN2db.py b/libpyEM/EMAN2db.py index 4a84b51edf..b90c20bd5a 100644 --- a/libpyEM/EMAN2db.py +++ b/libpyEM/EMAN2db.py @@ -58,6 +58,14 @@ from libpyEMData2 import EMData from libpyUtils2 import EMUtil +try: + from pyStarDB import sp_pystardb as star +except ImportError: + print("pyStarDB package is required in to use star files with EMData object") + +import pandas as pd +import numpy as np + # If set, fairly verbose debugging information will be written to the console # larger numbers will increase the amount of output DBDEBUG = 0 @@ -271,17 +279,22 @@ def db_open_dict(url, ro=False, with_keys=False): comma-separated list of keys. Thus it is impossible to access data items with keys like '1' instead of (int)1 using this mechanism. ro is a read only flag, which will disable caching as well.""" - path, dictname, keys = db_parse_path(url) + if url[:4].lower() == "bdb:" : + path, dictname, keys = db_parse_path(url) - ddb = EMAN2DB.open_db(path) - ddb.open_dict(dictname, ro=ro) + ddb = EMAN2DB.open_db(path) + ddb.open_dict(dictname, ro=ro) - if with_keys: - if ro: return (ddb[dictname + "__ro"], keys) - return (ddb[dictname], keys) + if with_keys: + if ro: return (ddb[dictname + "__ro"], keys) + return (ddb[dictname], keys) - if ro: return ddb[dictname + "__ro"] - return ddb[dictname] + if ro: return ddb[dictname + "__ro"] + return ddb[dictname] + elif url.endswith('.star'): + return Pd_to_Db_conversion.open_db(url) + else: + pass def db_close_dict(url): @@ -289,15 +302,21 @@ def db_close_dict(url): After closing, a dict CAN be reopened, but references to existing dict objects should not be used after closing. Ignores non bdb: urls""" - try: - path, dictname, keys = db_parse_path(url) - except: - return - - ddb = EMAN2DB.open_db(path) - ddb.close_dict(dictname) + if url[:4].lower() == "bdb:" : + try: + path, dictname, keys = db_parse_path(url) + except: + return - return + ddb = EMAN2DB.open_db(path) + ddb.close_dict(dictname) + return + elif url.endswith('.star'): + data = Pd_to_Db_conversion.open_db(url) + data.star.write_star_file(out_star_file=url, overwrite=True) + return + else: + pass def db_remove_dict(url): @@ -371,6 +390,14 @@ def db_get_image_count(fsp): for i in keys: if i in db: n += 1 return n + elif fsp.endswith('.star'): + star_file = star.StarFile(fsp) + try: + data = star_file['particles'] + except: + data = star_file[''] + return data.shape[0] + try: ret = EMUtil.get_image_count_c(fsp) except: @@ -478,6 +505,58 @@ def db_get_all_attributes(fsp, *parms): else: keys = parms[0] return [db.get_attr(i, attr_name) for i in keys] + + elif fsp.endswith('.star'): + star_file = star.StarFile(fsp) + try: + data = star_file['particles'] + except KeyError: + data = star_file[''] + special_keys = star_file.special_keys + if parms[0] in special_keys: + if parms[0] == 'ctf': + ctf_list = [] + for idx in range(data.shape[0]): + star_data = data.iloc[idx] + ctfdict = get_emdata_ctf(star_data) + ctf = EMAN2Ctf() + ctf.from_dict(ctfdict) + ctf_list.append(ctf) + del ctfdict + del star_data + return ctf_list + elif parms[0] == 'xform.projection': + trans_list = [] + for idx in range(data.shape[0]): + star_data = data.iloc[idx] + transdict = get_emdata_transform(star_data) + trans = Transform(transdict) + trans_list.append(trans) + del transdict + del star_data + return trans_list + elif parms[0] == 'xform.align2d': + trans_list = [] + for idx in range(data.shape[0]): + star_data = data.iloc[idx] + transdict = get_emdata_transform_2d(star_data) + trans = Transform(transdict) + trans_list.append(trans) + del transdict + del star_data + return trans_list + elif parms[0] == 'ptcl_source_coord': + cord_list = [] + for idx in range(data.shape[0]): + star_data = data.iloc[idx] + cord_list.append([int(star_data["_rlnCoordinateX"]), int(star_data["_rlnCoordinateY"])]) + return cord_list + else: + assert False, 'Missing rule for {}'.format(parms[0]) + else: + key = star.sphire_header_magic(parms[0], special_keys) + return data[key] + return EMUtil.get_all_attributes_c(fsp, *parms) @@ -1727,5 +1806,358 @@ def load_item(self, key, fkey=b'', txn=None): the entire refinement process.""" +######## Part of Code which is only required for Star support ################ + +def db_set_header_star(img, dataframe, star_cla): + """ + Uses the dataframe and the starclass to insert the data into + the EMData image with respect to specific keys. + """ + star_dict = star_cla.sphire_keys + fixed_keys = ['_rlnImageName'] + for key in dataframe.keys(): + if key in fixed_keys: + continue + else: + if key in star_dict: + value = dataframe[key] + img.set_attr(star_dict[key], value) + else: + sphire_key = star.sphire_header_magic(key, star_dict) + if sphire_key: + continue + else: + value = dataframe[key] + if type(value) == np.int64: + value = np.int32(value) + else: + value = value + img.set_attr(key, float(value)) + + try: + image_name = dataframe['_rlnImageName'] + number, file_name = image_name.split('@') + img.set_attr("data_path", file_name) + img.set_attr("ptcl_source_coord_id", int(number) - 1) + except Exception as e: + pass + + try: + ctfimg = EMAN2Ctf() + ctfdict = get_emdata_ctf(dataframe) + ctfimg.from_dict(ctfdict) + img.set_attr("ctf", ctfimg) + except Exception as e: + pass + + try: + transdict = get_emdata_transform(dataframe) + trans = Transform(transdict) + img.set_attr("xform.projection", trans) + except Exception as e: + pass + + try: + transdict = get_emdata_transform_2d(dataframe) + trans = Transform(transdict) + img.set_attr("xform.align2d", trans) + except Exception as e: + pass + + try: + cor = [int(dataframe["_rlnCoordinateX"]), int(dataframe["_rlnCoordinateY"])] + img.set_attr('ptcl_source_coord', cor) + except Exception as e: + pass + img.update() + return + +def db_em_to_star_header(em_dict, dataframe, ptcl_no, special_keys, ignored_keys): + """ + It converts the data from EMAN dictionary and pass it all + to pandas dataframe after conversion of keys. + """ + # print("Particle number", ptcl_no) + for key in list(em_dict.keys()): + em_key = star.sphire_header_magic(key, special_keys) + if em_key: + dataframe.loc[ptcl_no, em_key] = em_dict[key] + elif key[0:2] == '_r': + dataframe.loc[ptcl_no, key] = em_dict[key] + else: + if key in special_keys: + if key == 'ctf': + ctfdict = em_dict[key].to_dict() + defocus = ctfdict['defocus'] + dataframe.loc[ptcl_no, "_rlnDefocusU"] = ( + (20000 * ctfdict["defocus"] - 10000 * ctfdict["dfdiff"]) / 2 + ) + + dataframe.loc[ptcl_no, "_rlnDefocusV"] = ( + 20000 * ctfdict["defocus"] - + dataframe.loc[ptcl_no, "_rlnDefocusU"] + ) + dataframe.loc[ptcl_no, "_rlnCtfBfactor"] = ctfdict["bfactor"] + dataframe.loc[ptcl_no , "_rlnAmplitudeContrast"] = ctfdict["ampcont"] / 100 + dataframe.loc[ptcl_no , "_rlnDetectorPixelSize"] = ctfdict["apix"] + dataframe.loc[ptcl_no , "_rlnMagnification"] = 10000 + dataframe.loc[ptcl_no , "_rlnVoltage"] = ctfdict["voltage"] + dataframe.loc[ptcl_no , "_rlnSphericalAberration"] = ctfdict["cs"] + dataframe.loc[ptcl_no , "_rlnDefocusAngle"] = 45 - ctfdict["dfang"] + elif key == 'xform.projection': + trans = em_dict[key].get_params("spider") + dataframe.loc[ptcl_no , "_rlnAngleRot"] = trans["phi"] + dataframe.loc[ptcl_no , "_rlnAngleTilt"] = trans["theta"] + dataframe.loc[ptcl_no , "_rlnAnglePsi"] = trans["psi"] + dataframe.loc[ptcl_no , "_rlnOriginX"] = -trans["tx"] + dataframe.loc[ptcl_no , "_rlnOriginY"] = -trans["ty"] + elif key == 'xform.align2d': + trans = em_dict[key].get_params("2d") + dataframe.loc[ptcl_no , "_rlnAnglePsi"] = trans["alpha"] + dataframe.loc[ptcl_no , "_rlnOriginX"] = -trans["tx"] + dataframe.loc[ptcl_no , "_rlnOriginY"] = -trans["ty"] + elif key == 'ptcl_source_coord': + dataframe.loc[ptcl_no , "_rlnCoordinateX"] = int(em_dict[key][0]) + dataframe.loc[ptcl_no , "_rlnCoordinateY"] = int(em_dict[key][1]) + elif key == 'data_path': + try: + part_path = str("{:08n}".format(em_dict["ptcl_source_coord_id"] + 1)) + '@' + em_dict[ + "data_path"] + dataframe.loc[ptcl_no, '_rlnImageName'] = part_path + except Exception as e: # if datapath is not provided + print(e) + pass + elif key == 'originalid': + try: + dataframe.loc[ptcl_no , '_rlnOriginalid'] = em_dict[key] + except Exception as e: # if datapath is not provided + print(e) + pass + else: + assert False, 'Missing rule for {}'.format(key) + elif key in ignored_keys: + pass + + else: + print("Missing Keys are {}".format(key)) + return + +class Pd_to_Db_conversion(): + """ + The class helps the starfile class in adopting the behavior of db_open_dict and + db_close_dict. + In general this class should wrap around the starclass so that if you pass dict + to a pandas dataframe at particular index, it should do its magic and save the dictionary + properly in the pandas dataframe + """ + + opendbs = {} + lock = threading.Lock() + + def open_db(path=None): + """This is an alternate constructor which may return a cached (already open) + sphire instance""" + + Pd_to_Db_conversion.lock.acquire() + + if not path: path = e2gethome() + "/.eman2" + if path == "." or path == "./": path = e2getcwd() + if path in Pd_to_Db_conversion.opendbs: + Pd_to_Db_conversion.lock.release() + return Pd_to_Db_conversion.opendbs[path] + ret = Pd_to_Db_conversion(star.StarFile(path)) + Pd_to_Db_conversion.lock.release() + return ret + + def __init__(self, StarFile, special_key=None): + self.index = 0 + self.star = StarFile + if special_key != None: + self.converter = StarFile[special_key] + else: + try: + try: + self.converter = StarFile['particles'] + except KeyError: + self.converter = StarFile[''] + except: + self.star.update('particles', pd.DataFrame(), True) + self.converter = self.star['particles'] + + # Keep a cache of opened database environments + Pd_to_Db_conversion.opendbs[self.star.star_file] = self + + # Make the database directory + if not os.access(os.path.dirname(self.star.star_file), os.F_OK): + try: + os.makedirs(os.path.dirname(self.star.star_file)) + except: + # perhaps there is another process running that just made it? + if not os.access(os.path.dirname(self.star.star_file), os.F_OK): + raise RuntimeError("Error - there was a problem creating the Starfile directory") + + # Set the values of dict 'in_data' at a particualr index + def set(self, index, in_data): + if isinstance(in_data, dict): + special_keys = self.star.special_keys + ignored_keys = self.star.ignored_keys + db_em_to_star_header(in_data, self.converter, index, special_keys, ignored_keys) + else: + pass + + def __setitem__(self, index, data): + self.set(index, data) + + def get(self, index): + sp_keys = self.star.sphire_keys + return db_star_to_em_header(self.converter, index, sp_keys) + + def __getitem__(self, index): + return self.get(index) + + def get_attr(self, n, attr): + sp_keys = self.star.sphire_keys + newdict = db_star_to_em_header(self.converter, n, sp_keys) + return newdict[attr] + + def set_attr(self, n, attr, value): + sp_keys = self.star.special_keys + ign_keys = self.star.ignored_keys + em_dict = {attr: value} + db_em_to_star_header(em_dict, self.converter, n, sp_keys, ign_keys) + return + +def db_star_to_em_header(dataframe, idx, sphire_keys): + special_keys = ('ctf', 'xform.projection', 'ptcl_source_coord', 'xform.align2d', "data_path") + em_dict = {} + for key in special_keys: + if key == 'ctf': + ctfdict = get_emdata_ctf(dataframe.iloc[idx]) + ctf = EMAN2Ctf() + ctf.from_dict(ctfdict) + em_dict[key] = ctf + del ctfdict + + elif key == 'xform.projection': + transdict = get_emdata_transform(dataframe.iloc[idx]) + trans = Transform(transdict) + em_dict[key] = trans + del transdict + + elif key == 'xform.align2d': + transdict = get_emdata_transform_2d(dataframe.iloc[idx]) + trans = Transform(transdict) + em_dict[key] = trans + del transdict + elif key == 'ptcl_source_coord': + coord = [int(dataframe.iloc[idx]["_rlnCoordinateX"]), int(dataframe.iloc[idx]["_rlnCoordinateY"])] + em_dict[key] = coord + + elif key == 'data_path': + image_name = dataframe.iloc[idx]['_rlnImageName'] + number, file_name = image_name.split('@') + em_dict[key] = file_name + em_dict["ptcl_source_coord_id"] = int(number) - 1 + + else: + assert False, 'Missing rule for {}'.format(key) + + for keys in dataframe: + try: + if keys in sphire_keys: + new_key = sphire_keys[keys] + else: + sp = special_keys + new_key = star.sphire_header_magic(keys, sp) + if new_key == keys: + continue + else: + value = dataframe.iloc[idx][keys] + if isinstance(value, np.int64): + value = np.int32(value) + else: + value = value + em_dict[new_key] = value + except KeyError: + pass + + return em_dict + +""" +Conversion functions +""" + +def get_emdata_ctf(star_data): + idx_cter_astig_ang = 45 - star_data["_rlnDefocusAngle"] + if idx_cter_astig_ang >= 180: + idx_cter_astig_ang -= 180 + else: + idx_cter_astig_ang += 180 + + try: + ctfdict = {"defocus": ((star_data["_rlnDefocusU"] + + star_data["_rlnDefocusV"]) / 20000), + "bfactor": star_data["_rlnCtfBfactor"], + "ampcont": 100 * star_data["_rlnAmplitudeContrast"], + "apix": (10000 * star_data["_rlnDetectorPixelSize"]) / + star_data["_rlnMagnification"], + "voltage": star_data["_rlnVoltage"], + "cs": star_data["_rlnSphericalAberration"], + "dfdiff": ((-star_data["_rlnDefocusU"] + + star_data["_rlnDefocusV"]) / 10000), + "dfang": idx_cter_astig_ang + } + except: + ctfdict = {"defocus": ((star_data["_rlnDefocusU"] + + star_data["_rlnDefocusV"]) / 20000), + "bfactor": 0.0, + "ampcont": 100 * star_data["_rlnAmplitudeContrast"], + "apix": (10000 * star_data["_rlnDetectorPixelSize"]) / + star_data["_rlnMagnification"], + "voltage": star_data["_rlnVoltage"], + "cs": star_data["_rlnSphericalAberration"], + "dfdiff": ((-star_data["_rlnDefocusU"] + + star_data["_rlnDefocusV"]) / 10000), + "dfang": idx_cter_astig_ang + } + return ctfdict + +def get_emdata_transform(star_data): + try: + trans_dict = { + "type": "spider", + "phi": star_data["_rlnAngleRot"], + "theta": star_data["_rlnAngleTilt"], + "psi": star_data["_rlnAnglePsi"], + "tx": -star_data["_rlnOriginX"], + "ty": -star_data["_rlnOriginY"], + "tz": 0.0, + "mirror": 0, + "scale": 1.0 + } + except Exception as e : + pass + return trans_dict + +def get_emdata_transform_2d(star_data): + try: + trans_dict = { + "type": "2d", + "tx": -star_data["_rlnOriginX"], + "ty": -star_data["_rlnOriginY"], + "alpha": star_data["_rlnAnglePsi"], + "mirror": 0, + "scale": 1.0 + } + except Exception as e: + pass + return trans_dict + + +from EMAN2 import EMAN2Ctf +from EMAN2 import Transform + + + diff --git a/sphire/doc/higher_ord_abber.txt b/sphire/doc/higher_ord_abber.txt new file mode 100644 index 0000000000..904e9ff40c --- /dev/null +++ b/sphire/doc/higher_ord_abber.txt @@ -0,0 +1,88 @@ +~~NOTOC~~ + +===== sp_higher_ord_abber ===== +Relion CTF Refinement: Apply relion ctf refinement for higher order aberration correction + +\\ +===== Usage ===== + +Usage in command line + + sp_higher_ord_abber.py post_refine_folder output_folder --estimate_magnification --estimate_beamtilt --estimate_trefoil --estimate_order_aberation --perform_CTF_params_fit --fit_defocus_micrograph --fit_defocus_particle --fit_astigmatism_micrograph --fit_astigmatism_particle --fit_bfactor_micrograph --fit_bfactor_particle --fit_phase_shift_micrograph --fit_phase_shift_particle --min_res_fit --submission_template --submission_command --relion_mpirun_executable --relion_ctfrefine_executable --mpi_procs --no_of_threads --mrc_reloc_folder + +\\ +===== Typical usage ===== + +\\ __1. Applying ctf refinement __: + + sp_higher_ord_abber.py 12_POSTREFINER --submission_template='asdf' --submission_command='fasd' --mpi_procs=1 --no_of_threads=12 + + +\\ +===== Input ===== +=== Main Parameters === + ; post_refine_folder : Post Refine Folder: Input folder is the directory where the results of the post refiner are present and python routine automatically locates all the required files used for ctf refinement. (default required string) + ; output_folder : Output folder : Output folder is the directory where all the results of the ctf refinement are saved. (default required string) + ; %%--%%estimate_magnification : Estimate (anisotropic) magnification : Estimate magnification of dataset . (default False) + ; %%--%%estimate_beamtilt : Estimate beamtilt : Estimate beamtilt from the dataset. (default False) : %%--%%estimate_magnification==False + ; %%--%%estimate_trefoil : Also estimate trefoil : estimate 3-fold astigmatism per optics group .(default False) : %%--%%estimate_magnification==False + ; %%--%%estimate_order_aberation : Estimate the 4th order aberrations : Estimate the 4th order aberation .(default False) : %%--%%estimate_magnification==False + ; %%--%%perform_CTF_params_fit : Perform CTF parameter fitting : Perform CTF parameter fitting. (default False) : %%--%%estimate_magnification==False + ; %%--%%fit_defocus_micrograph : Fit defocus based on micrographs : Fit defocus based on micrographs. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_defocus_particle : Fit defocus based on particles : Fit defocus based on particles. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_astigmatism_micrograph : Fit astigmatism based on micrographs : Fit astigmatism based on micrographs .(default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_astigmatism_particle : Fit astigmatism based on particles : Fit astigmatism based on particles. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_bfactor_micrograph : Fit bfactor based on micrographs : Fit bfactor based on micrographs. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_bfactor_particle : Fit bfactor based on particles : Fit bfactor based on particles. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_phase_shift_micrograph : Fit phase shift estimation for micrographs : Fit phase shift estimation for micrographs .(default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%fit_phase_shift_particle : Fit phase shift estimation for particles : Fit phase shift estimation for particles. (default False) : %%--%%estimate_magnification==False %%--%%perform_CTF_params_fit==True + ; %%--%%min_res_fit : minimum resolution value for fitting (A) : minimum resolution value for fitting (default 30.0) + ; %%--%%submission_template : Submission template : Submission template for mpi command (default none) + ; %%--%%submission_command : Submission command : Submission commmand for cluster (default sbatch ||| qsub ||| bash) + ; %%--%%relion_mpirun_executable : relion mpirun executable : Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. (default mpirun) + ; %%--%%relion_ctfrefine_executable : relion ctf refine executable : Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion ctf refine executable also for that just type which relion_ctf_refine_mpi and copy the path here. (default relion_ctf_refine_mpi) + ; %%--%%mpi_procs : MPI Procs : The number of MPI processors used for Relion multiprocessing. (default 1) + ; %%--%%no_of_threads : number of threads : The number of threads use during the ctf refinement. (default 1) + + +\\ +=== Advanced Parameters === + ; %%--%%mrc_reloc_folder : mrc relocation folder : In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . (default none) + +\\ +===== Output ===== +The output is the result of the ctf refinement saved in the output_folder directory. + +\\ +=== List of Output Files === +|| **File Name** || **Discription** || + +\\ +==== Developer Notes ==== +=== 2020/01/06 Adnan Ali === + * Let me know if you find some bugs or want some modifications or improvement in the implementation. +\\ +==== Reference ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres: Estimation of high-order aberrations and anisotropic magnification from cryo-EM data sets in RELION-3.1, ''IUCrJ'' 7, 253-267, March, 2020. + +\\ +==== Author / Maintainer ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres + +\\ +==== Keywords ==== +Category 1:: APPLICATIONS + +\\ +==== Files ==== +sphire/bin/sp_higher_ord_abber.py + +\\ +==== Maturity ==== +Beta:: Under evaluation and testing. Please let us know if there are any bugs. + +\\ +==== Bugs ==== +None right now. + +\\ diff --git a/sphire/doc/pipe_isac_substack.txt b/sphire/doc/pipe_isac_substack.txt index b4d0d4c30b..8ccb7c4b54 100644 --- a/sphire/doc/pipe_isac_substack.txt +++ b/sphire/doc/pipe_isac_substack.txt @@ -8,7 +8,7 @@ ISAC2 Stack Subset: Create a virtual subset stack consisting of particles acount Usage in command line - sp_pipe.py isac_substack input_bdb_stack_path input_run_dir output_directory --isac_class_avgs_path=FILE_PATH --substack_basename=SUBSTACK_BASENAME + sp_pipe.py isac_substack input_star_stack_path input_run_dir output_directory --isac_class_avgs_path=FILE_PATH --substack_basename=SUBSTACK_BASENAME \\ ===== Typical usage ===== @@ -20,7 +20,7 @@ sp_pipe isac_substack does not support MPI. \\ ===== Input ===== === Main Parameters === - ; input_bdb_stack_path : Input bdb image stack: Specify the same bdb image stack used for the associated ISAC2 run. (default required string) + ; input_star_stack_path : Input Star image stack: Specify the same Star image stack used for the associated ISAC2 run. (default required string) ; input_run_dir : ISAC2 or Beautifier run output directory: Specify output directory of an ISAC2 or Beautifier run as an input to this command. From this directory, the program extracts the shrink ratio and 2D alignment parameters of the ISAC2 run or local 2D alignment parameters of the Beautifier run. (default required string) ; output_directory : Output directory: The results will be written here. It cannot be an existing one. (default required string) diff --git a/sphire/doc/pipe_restacking.txt b/sphire/doc/pipe_restacking.txt index 4ba647fc99..4b455aa3a0 100644 --- a/sphire/doc/pipe_restacking.txt +++ b/sphire/doc/pipe_restacking.txt @@ -8,7 +8,7 @@ Restacking: Generate all necessary information to restack the input stack (i.e., Usage in command line - sp_pipe.py restacking input_bdb_stack_path output_directory --selection_list=FILE_PATH --shift3d_x=SHIFT3D_X --shift3d_y=SHIFT3D_Y --shift3d_z=SHIFT3D_Z --save_vstack --sv_vstack_basename=BASENAME --reboxing --rb_box_size=BOX_SIZE + sp_pipe.py restacking input_star_stack_path output_directory --selection_list=FILE_PATH --shift3d_x=SHIFT3D_X --shift3d_y=SHIFT3D_Y --shift3d_z=SHIFT3D_Z --save_vstack --sv_vstack_basename=BASENAME --reboxing --rb_box_size=BOX_SIZE \\ ===== Typical usage ===== @@ -34,7 +34,7 @@ Do both restacking and reboxing to generate both the virtual stack and reboxing \\ ===== Input ===== === Main Parameters === - ; input_bdb_stack_path : Input bdb image stack: Specify the input bdb image stack. (default required string) + ; input_star_stack_path : Input star image stack: Specify the input star image stack. (default required string) ; output_directory : Output directory: The results will be written here. It cannot be an existing one. (default required string) ; %%--%%selection_list : Micrograph/Movie selection file: Specify path to text file containing a list of selected micrograph/movie names or paths. The particles associated with the micrographs/movies in this list will be processed. The file extension must be //.txt//. The directory path of each entry will be ignored if there is any. (default none) diff --git a/sphire/doc/polishing.txt b/sphire/doc/polishing.txt new file mode 100644 index 0000000000..87e743ad22 --- /dev/null +++ b/sphire/doc/polishing.txt @@ -0,0 +1,95 @@ +~~NOTOC~~ + +===== sp_polishing ===== +Relion Polishing: Apply relion polishing on SPHIRE generated stacks + +\\ +===== Usage ===== + +Usage in command line + + sp_polishing.py post_refine_folder motioncorr_starfile output_folder training_params --first_frame --last_frame --bfac_minfreq --bfac_maxfreq --min_no_particles --submission_template --submission_command --relion_mpirun_executable --relion_polishing_executable --mpi_procs --no_of_threads --mrc_reloc_folder + +\\ +===== Typical usage ===== + +\\ __1. Applying polishing using exisiting training data __: + + sp_polishing.py 12_POSTREFINER MotionCorr/job030/corrected_micrographs.star Polish/job156 Polish/job083/opt_params.txt --first_frame=1 --last_frame=-1 --bfac_minfreq=20 --bfac_maxfreq=-1 --submission_template='asdf' --submission_command='fasd' --mpi_procs=1 --no_of_threads=12 + +Note: The above case will use the optimize parameters from the training part. + +\\ __2. Applying training part of the polishing __: + + sp_polishing.py 12_POSTREFINER MotionCorr/job030/corrected_micrographs.star --first_frame=1 --last_frame=-1 --bfac_minfreq=20 --bfac_maxfreq=-1 --mpi_procs=1 --no_of_threads=12 + +Note: In case you want to do training part of polishing then dont provide the optimize parameter txt file + +\\ +===== Input ===== +=== Main Parameters === + ; post_refine_folder : Post Refine Folder: Input folder is the directory where the results of the post refiner are present. Python routine automatically locates all the required files used for polishing. (default required string) + ; motioncorr_starfile : MotionCorr Starfile: MotionCorr generated star file which normally is saved as corrected_micrographs.star (default required string) + ; output_folder : Output folder : Output folder is the directory where all the results of the polishing are saved. (default required string) + ;%%--%%training_params : training params : In case if the user wants to do the training part of the polishing then this is None. Otherwise provide the optimize_params.txt file. (default none) + + ; %%--%%min_no_particles : Minimum no of particles : Number of particles to inlcude for training. (default 5000) : %%--%%training_params==none + + ; %%--%%submission_template : Submission template : Submission template for mpi command (default none) + ; %%--%%submission_command : Submission command : Submission commmand for cluster (default sbatch ||| qsub ||| bash) + ; %%--%%relion_mpirun_executable : relion mpirun executable : Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. (default mpirun) + ; %%--%%relion_polishing_executable : relion polishing executable : Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion polishing executable also. Just type which relion_motion_refine_mpi and copy the path here. (default relion_motion_refine_mpi) + ; %%--%%mpi_procs :relion MPI Procs : The number of MPI processors used for Relion multiprocessing. (default 1) : %%--%%training_params!=none + ; %%--%%no_of_threads : relion number of threads : The number of threads use during the polishing. (default 1) + + +\\ +=== Advanced Parameters === + ; %%--%%first_frame : first frame [number] : The 1st frame number from where it should start. (default 1) + ; %%--%%last_frame : last frame [number] : The last frame number where it should end. (default -1) + ; %%--%%bfac_minfreq : minimum resolution for B-factor fit [A] : The minimum frequency range which is normally the maximum inner shell to include in enhancement. (default 20) + ; %%--%%bfac_maxfreq : maximum resolution for B-factor fit [A] : The minimum frequency range which is normally the maximum outer shell to include in enhancement. (default -1) + ; %%--%%mrc_reloc_folder : mrc relocation folder : In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . (default none) + + +\\ +===== Output ===== +The output is the result of the polishing saved in the output_folder directory. + +\\ +=== List of Output Files === +|| **File Name** || **Discription** || +|| opt_params_all_groups.txt || In case if the training part of the polishing is computed, then it generates txt file which contains the optimize parameters which are used for the later part of the polishing. || +|| bfactor.star || In case of applying polishing on the data, it calculates the bfactor for applying the weights on the particle images. || +|| shiny.star || In case of applying polishing on the data, it generates the metadata file for all the results. || +|| Movies/*_tracks.star || Per-Particles motion estimated shifts files. || + +\\ +==== Developer Notes ==== +=== 2020/01/06 Adnan Ali === + * Let me know if you find some bugs or want some modifications or improvement in the implementation. +\\ +==== Reference ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres: A Bayesian approach to beam-induced motion correction in cryo-EM single-particle analysis, ''IUCrJ'' 6, 5-17, January, 2019. + +\\ +==== Author / Maintainer ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres + +\\ +==== Keywords ==== +Category 1:: APPLICATIONS + +\\ +==== Files ==== +sphire/bin/sp_polishing.py + +\\ +==== Maturity ==== +Beta:: Under evaluation and testing. Please let us know if there are any bugs. + +\\ +==== Bugs ==== +None right now. + +\\ diff --git a/sphire/doc/relion_3dclassifi.txt b/sphire/doc/relion_3dclassifi.txt new file mode 100644 index 0000000000..74a47b1372 --- /dev/null +++ b/sphire/doc/relion_3dclassifi.txt @@ -0,0 +1,125 @@ +~~NOTOC~~ + +===== sp_relion_3dclassifi ===== +Relion 3D Classfication: A wrapper to call the relion 3D classification from the SPHIRE gui. +\\ +===== Usage ===== + +Usage in command line + + sp_relion_3dclassifi.py post_refine_folder output_folder reference_map --reference_mask --abs_greyscale_map --ini_high --sym --do_ctf --ctf_corr_ref --ctf_ignore_peak --no_of_class --tau_val --no_of_iter --diam_mas --zeros_mas --use_fast_sets --limit_resol_estep --skip_img_align --heal_pix_order --off_range --off_step --ang_search --ang_search_range --ang_search_relax_sym --coarse_sampling --para_io --no_of_pool_part --skip_pad --skip_grid --pre_read_img --scratch_dir --combine_iter_disc --use_gpu --which_gpu --submission_template --submission_command --relion_mpirun_executable --relion_3dclassification_executable --mpi_procs --no_of_threads --mrc_reloc_folder + +\\ +===== Typical usage ===== + +\\ __1. Applying 3d classification __: + + sp_relion_3dclassifi.py 12_POSTREFINER --submission_template='asdf' --submission_command='fasd' --mpi_procs=1 --no_of_threads=12 + + +\\ +===== Input ===== +=== Main Parameters === + ; post_refine_folder : Post Refine Folder: Input folder is the directory where the results of the post refiner are present and python routine automatically locates all the required files used for relion 3d classification. (default required string) + ; output_folder : Output folder : Output folder is the directory where all the results of the relion 3d classification are saved. (default required string) + ; reference_map : Reference map : Reference map to be used. (default required string) + ; %%--%%reference_mask : Reference mask (optional) : In case reference mask is provided by user . (default none) + ; %%--%%ini_high : initial low-pass filter (A) : initial low pass filter in angstroms. (default 60) + ; %%--%%sym : symmetry : symmetry use for classification. (default C1) + ; %%--%%do_ctf : Do CTF-correction : Whether to apply CTF correction or not. (default True) + ; %%--%%ctf_corr_ref : Has reference been CTF-corrected : Whether reference was CTF correction or not. (default False) + ; %%--%%ctf_ignore_peak : Ignore CTFs until first peak : Whether or not the first peak should be ignored or not .(default False) + ; %%--%%no_of_class : Number of classes : Number of classes to have. (default 1) + ; %%--%%tau_val : Regularisation parameter T : Regularized parameter adjusted. (default 4) + ; %%--%%no_of_iter : Number of iterations : Number of iterations to be performed. (default 25) + ; %%--%%diam_mas: Mask diameter (A) : The diameter of the mask which use. (default 200) + ; %%--%%zeros_mas : Mask on individual particles with zeros : in case padding with zeros is required. (default True) + ; %%--%%limit_resol_estep: Limit resolution E-step to (A): to limit the resolution for fitting (default -1) + ; %%--%%heal_pix_order : Angular sampling interval in degrees : output value can be from 8 to 0 depends on selection of values from 0.1 to 30 degrees (default 7.5 ||| 0.1 ||| 0.2 ||| 0.5 ||| 0.9 ||| 1.8 ||| 3.7 ||| 15 ||| 30) + ; %%--%%off_range : Offset search range (pix) : Probabilities will be calculated only for translations in a circle with this radius in pixels. (default 5) + ; %%--%%off_step : Offset search step (pix) : Translations will be sampled with this step size in pixels. (default 1) + ; %%--%%coarse_sampling : Allow coarser sampling : flag only , if allow coarser sampling is set to Yes. (default False) + ; %%--%%no_of_pool_part : Number of pooled particles : The nr_pooled_particles parameter controls how many particles are read together for each thread. (default 3) + ; %%--%%use_gpu : Use GPU acceleration : Whether to use gpu for computation or not. (default False) + ; %%--%%which_gpu : Which GPU to use : the index value of the GPU to use. (default None) : %%--%%use_gpu==True + ; %%--%%submission_template : Submission template : Submission template for mpi command (default None) + ; %%--%%submission_command : Submission command : Submission commmand for cluster (default sbatch ||| qsub ||| bash) + ; %%--%%relion_mpirun_executable : relion mpirun executable : Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. (default mpirun) + ; %%--%%relion_3dclassification_executable : relion 3dclassification executable : Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion ctf refine executable also for that just type which relion_ctf_refine_mpi and copy the path here. (default relion_refine_mpi) + ; %%--%%mpi_procs : MPI Procs : The number of MPI processors used for Relion multiprocessing. (default 1) + ; %%--%%no_of_threads : number of threads : The number of threads use during the ctf refinement. (default 1) + + +\\ +=== Advanced Parameters === + ; %%--%%abs_greyscale_map : Ref map is on absolute greyscale : Whether the reference map is on absolute greyscale level or not. (default False) + ; %%--%%use_fast_sets : Use fast subsets for large datasets : if selected the first 5 iterations will be done with random subsets of only K*1500 particles. (default False) + ; %%--%%skip_img_align : Skip image alignment : Whether to skip image alignment or not . (default False) + ; %%--%%ang_search : Perform local angular searches : Whether to perform angular search or not. (default False) + ; %%--%%ang_search_range : Local angular search range: in case if is set to Yes, value is multiplied by 0.33333. (default 5) : %%--%%ang_search==True + ; %%--%%ang_search_relax_sym : Relax Symmetry : to relax symmetry . (default None) : %%--%%ang_search==True + ; %%--%%para_io : Use parallel disc I/O :if use parallel disc I/O is set to No. (default True) + ; %%--%%skip_pad : Skip padding : depends on the answer for skip padding, if set to No , then pad is 2 , if set to yes then pad is 1. (default False) + ; %%--%%skip_grid : Skip gridding : Whether to skip the grid or not. (default True) + ; %%--%%pre_read_img : Pre-read all particles into RAM : reading all particles images in memory. (default False) + ; %%--%%scratch_dir : Copy particles to search directory : if --preread_images is set to No and if a directory link is provided in Copy particles to scratch directory (default None) + ; %%--%%combine_iter_disc : Combine iterations through disc : Whether to combine iterations or not. (default False) + ; %%--%%mrc_reloc_folder : mrc relocation folder : In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . (default None) +# ; %%--%%helical_recons : Do helical reconstruction : If selected then perform 3D helical reconstruction. (default False) +# ; %%--%%inner_diam : Tube inner diameter (A) : Helical tube inner diameter. (default -1) : %%--%%helical_recons==True +# ; %%--%%outer_diam : Tube outer diameter (A) : Helical tube outer diameter. (default -1) : %%--%%helical_recons==True +# ; %%--%%sig_tilt : Angular search range for tilt (deg) : angular search range value in degrees for tilt. (default 15) : %%--%%helical_recons==True +# ; %%--%%sig_psi : Angular search range for psi (deg) : angular search range value in degrees for psi. (default 10) : %%--%%helical_recons==True +# ; %%--%%sig_rot : Angular search range for rot (deg) : angular search range value in degrees for rot. (default -1) : %%--%%helical_recons==True +# ; %%--%%sigma_dist : Range factor of local averaging : Local averaging of orientations and translations will be performed within a range of +/- this value * the box size.(default 1.5) : %%--%%helical_recons==True +# ; %%--%%keep_tilt_fix : Keep tilt-prior fixed : Tilt prior will not change during the optimization. (default True) : %%--%%helical_recons==True +# ; %%--%%apply_helical_sym : Apply helical symmetry : Whether to apply helical symmetry or not . (default False) : %%--%%helical_recons==True +# ; %%--%%unique_asym_unit : Number of unique asymmetrical units : No of unique units in each segment box. (default 1) : %%--%%helical_recons==True %%--%%apply_helical_sym==True +# ; %%--%%initial_twist : Initial twist (deg) : set to positive value if it is a right-handed helix. (default 0) : %%--%%helical_recons==True %%--%%apply_helical_sym==True +# ; %%--%%initial_rise : Initial rise (A) : set to positivie value .(default 0) : %%--%%helical_recons==True %%--%%apply_helical_sym==True +# ; %%--%%z_percent : Central Z length (%) : Information from the central part of the box is used for search and imposing helical symmetry in real space. (default 30) : %%--%%helical_recons==True %%--%%apply_helical_sym==True +# ; %%--%%do_local_search : Do local searches of symmetry : Peform local searches of helical twist and rise within given range . (default False) : %%--%%helical_recons==True +# ; %%--%%twist_min : Twist search minimum (deg) : Miniumum value for twist search. Set it to a positive value if it is a right-handed helix. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True +# ; %%--%%twist_max : Twist search maxiumum (deg) : Maxiumum value for twist search. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True +# ; %%--%%twist_inistep : Twist search initial step (deg): Need to set manually set if the default value does not guarantee convergence. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True +# ; %%--%%rise_min : Rise search minimum (A) : Minimum value for rise search . Set is to a positive value in angstorms. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True +# ; %%--%%rise_max : Rise search maxiumum (A) : Maximum value for rise search. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True +# ; %%--%%rise_inistep : Rise search initial step (A) : Need to set manually set if the default value does not guarantee convergence. (default 0) : %%--%%helical_recons==True %%--%%do_local_search==True + +\\ +===== Output ===== +The output is the result of the ctf refinement saved in the output_folder directory. + +\\ +=== List of Output Files === +|| **File Name** || **Discription** || + +\\ +==== Developer Notes ==== +=== 2020/01/06 Adnan Ali === + * Let me know if you find some bugs or want some modifications or improvement in the implementation. +\\ +==== Reference ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres: Estimation of high-order aberrations and anisotropic magnification from cryo-EM data sets in RELION-3.1, ''IUCrJ'' 7, 253-267, March, 2020. + +\\ +==== Author / Maintainer ==== +Jasenko Zivanov, Takanori Nakane and Sjors H W Scheres + +\\ +==== Keywords ==== +Category 1:: APPLICATIONS + +\\ +==== Files ==== +sphire/bin/sp_relion_3dclassifi.py + +\\ +==== Maturity ==== +Beta:: Under evaluation and testing. Please let us know if there are any bugs. + +\\ +==== Bugs ==== +None right now. + +\\ diff --git a/sphire/sphire/bin/sp_auto.py b/sphire/sphire/bin/sp_auto.py index bd506e5260..7230c804c6 100755 --- a/sphire/sphire/bin/sp_auto.py +++ b/sphire/sphire/bin/sp_auto.py @@ -40,7 +40,7 @@ import argparse -from ..libpy import sp_global_def +from sphire.libpy import sp_global_def import subprocess import collections import sys @@ -915,9 +915,9 @@ def get_window(status_dict, negative_stain, filament_mode, **kwargs): def get_window_stack(**kwargs): cmd = [] - cmd.append("e2bdb.py") + cmd.append("sp_star.py") cmd.append("XXX_SP_WINDOW_OUTPUT_DIR_XXX/mpi_proc_*") - cmd.append("--makevstack=bdb:XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack") + cmd.append("--makevstack=XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack.star") return cmd @@ -925,7 +925,7 @@ def get_isac2(status_dict, phase_plate, negative_stain, **kwargs): cmd = [] cmd.append("sp_isac2.py") if status_dict["do_window"]: - cmd.append("bdb:XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack") + cmd.append("XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack.star") else: cmd.append("XXX_SP_ISAC_STACK_XXX") cmd.append("XXX_SP_ISAC_OUTPUT_DIR_XXX") @@ -962,7 +962,7 @@ def get_isac2_substack(status_dict, **kwargs): cmd.append("sp_pipe.py") cmd.append("isac_substack") if status_dict["do_window"]: - cmd.append("bdb:XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack") + cmd.append("XXX_SP_WINDOW_OUTPUT_DIR_XXX/stack.star") else: cmd.append("XXX_SP_ISAC_STACK_XXX") @@ -1044,7 +1044,7 @@ def get_meridien(status_dict, filament_mode, **kwargs): cmd.append('sp_meridien.py') if status_dict["do_isac2"]: - cmd.append("bdb:XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack") + cmd.append("XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack.star") else: cmd.append("XXX_SP_MERIDIEN_INPUT_STACK_XXX") cmd.append("XXX_SP_MERIDIEN_OUTPUT_DIR_XXX") @@ -1106,7 +1106,7 @@ def get_restack_import_params(status_dict, **kwargs): if status_dict["do_meridien"] and status_dict["do_restack"]: cmd.append("sp_header.py") if status_dict["do_isac2"]: - cmd.append("bdb:XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack") + cmd.append("XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack.star") else: cmd.append("XXX_SP_MERIDIEN_INPUT_STACK_XXX") cmd.append("--import=$(ls XXX_SP_MERIDIEN_OUTPUT_DIR_XXX/final_params_*.txt)") @@ -1120,7 +1120,7 @@ def get_restack_box_files(status_dict, **kwargs): cmd.append("sp_pipe.py") cmd.append("restacking") if status_dict["do_isac2"]: - cmd.append("bdb:XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack") + cmd.append("XXX_SP_SUBSTACK_OUTPUT_DIR_XXX/isac_substack.star") else: cmd.append("XXX_SP_MERIDIEN_INPUT_STACK_XXX") cmd.append("XXX_SP_RESTACK_OUTPUT_DIR_XXX") @@ -1162,9 +1162,9 @@ def get_restack_window(status_dict, **kwargs): def get_restack_stack(status_dict, **kwargs): cmd = [] - cmd.append("e2bdb.py") + cmd.append("sp_star.py") cmd.append("XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/mpi_proc_*") - cmd.append("--makevstack=bdb:XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/stack") + cmd.append("--makevstack=XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/stack.star") return cmd @@ -1172,7 +1172,7 @@ def get_restack_meridien(status_dict, **kwargs): cmd = [] if status_dict["do_meridien"] and status_dict["do_restack"]: cmd.append("sp_meridien.py") - cmd.append("bdb:XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX#stack") + cmd.append("XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/stack.star") cmd.append("XXX_SP_RESTACK_MERIDIEN_OUTPUT_DIR_XXX") cmd.append("XXX_SP_SHARPENING_MERIDIEN_OUTPUT_DIR_XXX/vol_combined.hdf") cmd.append("--skip_prealignment") @@ -1213,7 +1213,7 @@ def get_ctf_import_params(status_dict, **kwargs): and status_dict["do_restack"] ): cmd.append("sp_header.py") - cmd.append("bdb:XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX#stack") + cmd.append("XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/stack.star") cmd.append( "--import=$(ls XXX_SP_RESTACK_MERIDIEN_OUTPUT_DIR_XXX/final_params_*.txt)" ) @@ -1230,7 +1230,7 @@ def get_ctf_refine(status_dict, **kwargs): ): cmd.append("sp_ctf_refine.py") cmd.append("meridien") - cmd.append("bdb:XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX#stack") + cmd.append("XXX_SP_RESTACK_WINDOW_OUTPUT_DIR_XXX/stack.star") cmd.append("XXX_SP_CTF_REFINE_OUTPUT_DIR_XXX") cmd.append("XXX_SP_RESTACK_MERIDIEN_OUTPUT_DIR_XXX") cmd.append( @@ -1246,7 +1246,7 @@ def get_ctf_meridien(status_dict, **kwargs): cmd = [] if status_dict["do_meridien"] and status_dict["do_restack"]: cmd.append("sp_meridien.py") - cmd.append("bdb:XXX_SP_CTF_REFINE_OUTPUT_DIR_XXX#ctf_refined") + cmd.append("XXX_SP_CTF_REFINE_OUTPUT_DIR_XXX/ctf_refined.star") cmd.append("XXX_SP_CTF_MERIDIEN_OUTPUT_DIR_XXX") cmd.append("XXX_SP_RESTACK_SHARPENING_OUTPUT_DIR_XXX/vol_combined.hdf") cmd.append("--skip_prealignment") diff --git a/sphire/sphire/bin/sp_ctf_refine.py b/sphire/sphire/bin/sp_ctf_refine.py index 9c3ee14509..70e82a4970 100755 --- a/sphire/sphire/bin/sp_ctf_refine.py +++ b/sphire/sphire/bin/sp_ctf_refine.py @@ -46,13 +46,13 @@ import copy import multiprocessing import numpy -from ..libpy import sp_global_def -from ..libpy import sp_projection -from ..libpy import sp_statistics -from ..libpy import sp_utilities -from ..libpy import sp_ctf_refine_io -from ..libpy import sp_ctf_refine_plotting -from ..libpy import sp_filter +from sphire.libpy import sp_global_def +from sphire.libpy import sp_projection +from sphire.libpy import sp_statistics +from sphire.libpy import sp_utilities +from sphire.libpy import sp_ctf_refine_io +from sphire.libpy import sp_ctf_refine_plotting +from sphire.libpy import sp_filter import itertools import sys import time @@ -740,9 +740,10 @@ def run(): os.makedirs(output_folder) sp_global_def.write_command(output_folder) - output_virtual_stack_path = "bdb:" + os.path.join( - output_folder, "ctf_refined" - ) + # output_virtual_stack_path = "bdb:" + os.path.join( + # output_folder, "ctf_refined" + # ) + output_virtual_stack_path = os.path.join(output_folder, "ctf_refined.star") output_stats_path = os.path.join(output_folder, "statistics") diff --git a/sphire/sphire/bin/sp_gui.py b/sphire/sphire/bin/sp_gui.py index 24041281b3..67cbc45b90 100755 --- a/sphire/sphire/bin/sp_gui.py +++ b/sphire/sphire/bin/sp_gui.py @@ -43,20 +43,22 @@ import collections from builtins import range from builtins import object + try: - from PyQt4.Qt import * - from PyQt4 import QtGui - from PyQt4 import QtCore + from PyQt4.Qt import * + from PyQt4 import QtGui + from PyQt4 import QtCore except ImportError: - from PyQt5.Qt import * - from PyQt5 import QtWidgets as QtGui - from PyQt5 import QtCore + from PyQt5.Qt import * + from PyQt5 import QtWidgets as QtGui + from PyQt5 import QtCore from EMAN2 import * from EMAN2_cppwrap import * + try: from sphire.libpy import sp_global_def #### from ..libpy.sp_global_def import * from sphire.libpy.sp_global_def import sp_get_image_path - from sphire.libpy.sp_sparx import * #### from ..libpy.sp_sparx import * + from sphire.libpy.sp_sparx import * #### from ..libpy.sp_sparx import * import sphire except ImportError as e: #####print("Import error raised. Ignore.") @@ -71,96 +73,100 @@ # ======================================================================================== # Helper Functions -# +# # This function is added here because db_convert_path in EMAN2db.py has a bug. # - def translate_to_bdb_path(std_path): ''' - Translate a standard file path (std_path) to bdb syntax (return value). + Translate a standard file path (std_path) to bdb syntax (return value). The path pass must contain at lease EMAN2DB directory and .bdb file name. For instance, if the path is particles/EMAN2DB/data.bdb, will return bdb:particles#data. ''' - + # Check error conditions - if not isinstance(std_path,str): + if not isinstance(std_path, str): raise RuntimeError("Path has to be a string") path_tokens = std_path.split("/") - - if len(path_tokens) < 2: - raise ValueError("Invalid file path. The path pass must contain at least \'EMAN2DB\' directory and \'.bdb\' file name (e.g \'./EMAN2DB/data.bdb\'). ") - - if path_tokens[-2] != "EMAN2DB": - raise ValueError("Invalid file path. The path pass must contain \'EMAN2DB\' directory (e.g \'./EMAN2DB/data.bdb\').") - - if os.path.splitext(path_tokens[-1])[1] != ".bdb": + + if len(path_tokens) < 2: + raise ValueError( + "Invalid file path. The path pass must contain at least \'EMAN2DB\' directory and \'.bdb\' file name (e.g \'./EMAN2DB/data.bdb\'). ") + + if path_tokens[-2] != "EMAN2DB": + raise ValueError( + "Invalid file path. The path pass must contain \'EMAN2DB\' directory (e.g \'./EMAN2DB/data.bdb\').") + + if os.path.splitext(path_tokens[-1])[1] != ".bdb": raise ValueError("Path is invalid. The path pass must contain \'.bdb\' file name (e.g \'./EMAN2DB/data.bdb\').") - + # If necessary, compose directory path as a relative path at first dir = "" if len(path_tokens) > 2: for idx in range(0, len(path_tokens) - 2): if idx != 0: dir += "/" - dir += path_tokens[idx] # accrue the directory - + dir += path_tokens[idx] # accrue the directory + # if the input file path is a absolute path, add '/' at the head of the path - if std_path[0] == "/" and dir[0] != "/": + if std_path[0] == "/" and dir[0] != "/": dir = "/" + dir - + # Add '#' before the database name (file basename without extension) bdb_path = "bdb:" if dir != "": bdb_path += dir + "#" # Finally, add file basename (without .bdb extension) - assert(os.path.splitext(path_tokens[-1])[1] == ".bdb") + assert (os.path.splitext(path_tokens[-1])[1] == ".bdb") bdb_path += os.path.splitext(path_tokens[-1])[0] - + return bdb_path + # ======================================================================================== # Inherited by SXcmd_category, SXconst_set, and SXoperand_set # SXMainWindow use this class to handle events from menu item buttons class SXmenu_item(object): - def __init__(self, name = "", label = "", short_info = ""): + def __init__(self, name="", label="", short_info=""): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables - self.name = name # Name of this menu item, used as a key of dictionary - self.label = label # User friendly name of this menu item + self.name = name # Name of this menu item, used as a key of dictionary + self.label = label # User friendly name of this menu item self.short_info = short_info # Short description of this menu item - self.btn = None # QPushButton button instance associating with this menu item - self.widget = None # SXCmdWidget instance associating with this menu item - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.btn = None # QPushButton button instance associating with this menu item + self.widget = None # SXCmdWidget instance associating with this menu item +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + # ======================================================================================== class SXcmd_token(object): def __init__(self): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables - self.key_base = "" # key base name of command token (argument or option) in command line - self.key_prefix = "" # key prefix of of command token. None for argument, "--" or "-" for option - self.label = "" # User friendly name of argument or option - self.help = "" # Help info - self.group = "" # Tab group: main or advanced - self.dependency_group = [["", "", ""]] # Depencency group: Disables or enables widgets - self.is_required = False # Required argument or options. No default values are available - self.is_locked = False # The restore value will be used as the locked value. - self.is_reversed = False # Reversed default value of bool. The flag will be added if the value is same as default - self.default = "" # Default value - self.restore = [[""], [""]] # Restore value - self.type = "" # Type of value - self.filament_tab = "" # Type of value + self.key_base = "" # key base name of command token (argument or option) in command line + self.key_prefix = "" # key prefix of of command token. None for argument, "--" or "-" for option + self.label = "" # User friendly name of argument or option + self.help = "" # Help info + self.group = "" # Tab group: main or advanced + self.dependency_group = [["", "", ""]] # Depencency group: Disables or enables widgets + self.is_required = False # Required argument or options. No default values are available + self.is_locked = False # The restore value will be used as the locked value. + self.is_reversed = False # Reversed default value of bool. The flag will be added if the value is same as default + self.default = "" # Default value + self.restore = [[""], [""]] # Restore value + self.type = "" # Type of value + self.filament_tab = "" # Type of value # NOTE: Toshio Moriya 2018/01/19 # self.is_in_io should be removed after cleaning up MoinMoin related codes. - self.is_in_io = False # To check consistency between "usage in command line" and list in "== Input ==" and "== Output ==" sections - self.restore_widget = None # Restore widget instance associating with this command token - self.widget = None # Main widget instance associating with this command token - self.subwidget_left = None # Subwidget instance at the left associating with the helper utility of this command token (e.g. conversion calculator) - self.subwidget_right = None # SubWidget instance at the right associating with the helper utility of this command token (e.g. conversion calculator) - self.calculator_dialog = None # Calculator dialog instance associating with the helper utility of this command token (e.g. conversion calculator) - self.other_dialog_list = [] # List of the other calculator dialog instances associating with this command (e.g. conversion calculator) - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.is_in_io = False # To check consistency between "usage in command line" and list in "== Input ==" and "== Output ==" sections + self.restore_widget = None # Restore widget instance associating with this command token + self.widget = None # Main widget instance associating with this command token + self.subwidget_left = None # Subwidget instance at the left associating with the helper utility of this command token (e.g. conversion calculator) + self.subwidget_right = None # SubWidget instance at the right associating with the helper utility of this command token (e.g. conversion calculator) + self.calculator_dialog = None # Calculator dialog instance associating with the helper utility of this command token (e.g. conversion calculator) + self.other_dialog_list = [] # List of the other calculator dialog instances associating with this command (e.g. conversion calculator) + + # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< def initialize_edit(self, key_base): self.key_base = key_base @@ -175,62 +181,65 @@ def initialize_edit(self, key_base): self.restore = None self.type = None + # ======================================================================================== class SXcmd(object): - def __init__(self, category = "", role = "", is_submittable = True): + def __init__(self, category="", role="", is_submittable=True): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables - self.name = "" # Name of this command (i.e. name of sx*.py script but without .py extension), used for generating command line - self.subname = "" # Subname of this command (i.e. sub-command name), used for generating command line. For fullset command, use empty string - self.mode = "" # Key base name of a command option token, defining mode/subset of this command (i.e. option mode name). For fullset command, use empty string - self.subset_config = "" # Unique name to differentiate subset configuration of this command. For example, to name a command argument mode, which dependes on the number of input arguments. If not necessary, use empty string - self.label = "" # User friendly name of this command - self.short_info = "" # Short description of this command - self.mpi_support = False # Flag to indicate if this command suppors MPI version - self.mpi_add_flag = False # DESIGN_NOTE: 2015/11/12 Toshio Moriya. This can be removed when --MPI flag is removed from all sx*.py scripts - self.category = category # Category of this command: sxc_movie, sxc_cter, sxc_window, sxc_isac, sxc_viper, sxc_meridien, sxc_sort3d, sxc_localres, sxc_utilities - self.role = role # Role of this command; sxr_pipe (pipeline), sxr_alt (alternative) sxr_util (utility) + self.name = "" # Name of this command (i.e. name of sx*.py script but without .py extension), used for generating command line + self.subname = "" # Subname of this command (i.e. sub-command name), used for generating command line. For fullset command, use empty string + self.mode = "" # Key base name of a command option token, defining mode/subset of this command (i.e. option mode name). For fullset command, use empty string + self.subset_config = "" # Unique name to differentiate subset configuration of this command. For example, to name a command argument mode, which dependes on the number of input arguments. If not necessary, use empty string + self.label = "" # User friendly name of this command + self.short_info = "" # Short description of this command + self.mpi_support = False # Flag to indicate if this command suppors MPI version + self.mpi_add_flag = False # DESIGN_NOTE: 2015/11/12 Toshio Moriya. This can be removed when --MPI flag is removed from all sx*.py scripts + self.category = category # Category of this command: sxc_movie, sxc_cter, sxc_window, sxc_isac, sxc_viper, sxc_meridien, sxc_sort3d, sxc_localres, sxc_utilities + self.role = role # Role of this command; sxr_pipe (pipeline), sxr_alt (alternative) sxr_util (utility) self.is_submittable = is_submittable # External GUI Application (e.g. sxgui_cter.py) should not be submitted to job queue - self.token_list = [] # List of command tokens. Need this to keep the order of command tokens - self.token_dict = {} # Dictionary of command tokens, organised by key base name of command token. Easy to access a command token but looses their order - self.dependency_dict = collections.OrderedDict() # Dictionary of command tokens, containing the dependencies - self.btn = None # QPushButton button instance associating with this command - self.widget = None # SXCmdWidget instance associating with this command - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.token_list = [] # List of command tokens. Need this to keep the order of command tokens + self.token_dict = {} # Dictionary of command tokens, organised by key base name of command token. Easy to access a command token but looses their order + self.dependency_dict = collections.OrderedDict() # Dictionary of command tokens, containing the dependencies + self.btn = None # QPushButton button instance associating with this command + self.widget = None # SXCmdWidget instance associating with this command + + # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< def get_mode_name_for(self, target_name): mode_name = self.name - + if self.subname != "": if target_name in ["file_path"]: mode_name = "%s_%s" % (mode_name, self.subname) elif target_name in ["human"]: mode_name = "%s %s" % (mode_name, self.subname) - + if self.mode != "": if target_name in ["file_path"]: mode_name = "%s_%s" % (mode_name, self.mode) elif target_name in ["human"]: mode_name = "%s %s%s" % (mode_name, self.token_dict[self.mode].key_prefix, self.mode) - + if self.subset_config != "": if target_name in ["file_path"]: mode_name = "%s_%s" % (mode_name, self.subset_config.replace(" ", "_")) elif target_name in ["human"]: mode_name = "%s (%s)" % (mode_name, self.subset_config) - + return mode_name - def get_category_dir_path(self, parent_dir_path = ""): + def get_category_dir_path(self, parent_dir_path=""): category_dir_path = self.category.replace("sxc_", "") if parent_dir_path != "": category_dir_path = os.path.join(parent_dir_path, category_dir_path) return category_dir_path + # ======================================================================================== class SXcmd_category(SXmenu_item): - def __init__(self, name = "", label = "", short_info = ""): + def __init__(self, name="", label="", short_info=""): super(SXcmd_category, self).__init__(name, label, short_info) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -238,26 +247,29 @@ def __init__(self, name = "", label = "", short_info = ""): # self.name = name # Name of this command category (i.e. sxc_movie, sxc_cter, sxc_window, sxc_isac, sxc_viper, sxc_meridien, sxc_sort3d, sxc_localres, sxc_utilities), used as a key of dictionary # self.label = label # User friendly name of this command category # self.short_info = short_info # Short description of this command category - self.cmd_list = [] # list of commands in this category. Need this to keep the order of commands + self.cmd_list = [] # list of commands in this category. Need this to keep the order of commands + + # self.cmd_dict = {} # dictionary of commands in this category, organised by names of commands. Easy to access a command but looses their order - # self.btn = None # QPushButton button instance associating with this category - # self.widget = None # SXCmdWidget instance associating with this category +# self.btn = None # QPushButton button instance associating with this category +# self.widget = None # SXCmdWidget instance associating with this category - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # ======================================================================================== class SXconst(object): def __init__(self): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables - self.key = "" # key of constant parameter - self.label = "" # User friendly name of constant parameter - self.help = "" # Help info - self.register = "" # Default value - self.type = "" # Type of value + self.key = "" # key of constant parameter + self.label = "" # User friendly name of constant parameter + self.help = "" # Help info + self.register = "" # Default value + self.type = "" # Type of value self.register_widget = None # Restore widget instance associating with this command token - self.widget = None # Widget instance associating with this constant parameter - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.widget = None # Widget instance associating with this constant parameter +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + # ======================================================================================== class SXconst_set(SXmenu_item): @@ -268,28 +280,30 @@ def __init__(self): # self.name = "" # Name of this constant parameter set # self.label = "" # User friendly name of this set # self.short_info = "" # Short description of this set - self.list = [] # list of constant parameters. Need this to keep the order of constant parameters - self.dict = {} # dictionary of constant parameters, organised by keys of constant parameters. Easy to access each constant parameter but looses their order - # self.btn = None # QPushButton button instance associating with this set - # self.widget = None # Widget instance associating with this set - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.list = [] # list of constant parameters. Need this to keep the order of constant parameters + self.dict = {} # dictionary of constant parameters, organised by keys of constant parameters. Easy to access each constant parameter but looses their order +# self.btn = None # QPushButton button instance associating with this set +# self.widget = None # Widget instance associating with this set +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + # ======================================================================================== class SXoperand(object): def __init__(self): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables - self.key = "" # key of calculator operand - self.label = "" # User friendly name of calculator operand - self.help = "" # Help info - self.register = "" # Default value - self.type = "" # Type of value - self.is_input = True # Flag to indicate if this operand is input or output - self.validated_register = None # Contain validated numerical value of register only if the value is valid. If not, it is None. This is used as a flag to indicate if the registered value is valid or not - self.validated = None # Contain Validated numerical value of command widget only if the value is valid. If not, it is None. This is used as a flag to indicate if the registered value is valid or not - self.register_widget = None # Restore widget instance associating with this calculator operand - self.widget = None # Widget instance associating with this calculator operand - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.key = "" # key of calculator operand + self.label = "" # User friendly name of calculator operand + self.help = "" # Help info + self.register = "" # Default value + self.type = "" # Type of value + self.is_input = True # Flag to indicate if this operand is input or output + self.validated_register = None # Contain validated numerical value of register only if the value is valid. If not, it is None. This is used as a flag to indicate if the registered value is valid or not + self.validated = None # Contain Validated numerical value of command widget only if the value is valid. If not, it is None. This is used as a flag to indicate if the registered value is valid or not + self.register_widget = None # Restore widget instance associating with this calculator operand + self.widget = None # Widget instance associating with this calculator operand +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + # ======================================================================================== class SXoperand_set(SXmenu_item): @@ -300,34 +314,36 @@ def __init__(self): # self.name = "" # Name of this calculator operand set # self.label = "" # User friendly name of this set # self.short_info = "" # Short description of this set - self.list = [] # list of calculator operands. Need this to keep the order of calculator operands - self.dict = {} # dictionary of calculator operands, organised by keys of calculator operands. Easy to access each calculator operand but looses their order - # self.btn = None # QPushButton button instance associating with this set - # self.widget = None # Widget instance associating with this set - # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + self.list = [] # list of calculator operands. Need this to keep the order of calculator operands + self.dict = {} # dictionary of calculator operands, organised by keys of calculator operands. Easy to access each calculator operand but looses their order +# self.btn = None # QPushButton button instance associating with this set +# self.widget = None # Widget instance associating with this set +# ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< + # ======================================================================================== class SXLookFeelConst(object): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # static class variables # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< - default_bg_color = QColor(229, 229, 229, 192) # default_bg_color = QColor(229, 229, 229, 242) # Greyish-White Transparent - default_bg_color_string = 'rgba(229, 229, 229, 192)' # default_bg_color = QColor(229, 229, 229, 242) # Greyish-White Transparent - default_bg_color_calculator = QColor(214, 214, 214) # Greyish-White - sxinfo_widget_bg_color = QColor(0, 0, 0, 10) # Almost-Completely Transparent - sxcmd_widget_bg_color = QColor(0, 0, 0, 0) # Completely Transparent - sxcmd_tab_bg_color = QColor(229, 229, 229, 200) # White Transparent - sxcmd_tab_bg_color_string = 'rgba(229, 229, 229, 200)' # White Transparent + default_bg_color = QColor(229, 229, 229, + 192) # default_bg_color = QColor(229, 229, 229, 242) # Greyish-White Transparent + default_bg_color_string = 'rgba(229, 229, 229, 192)' # default_bg_color = QColor(229, 229, 229, 242) # Greyish-White Transparent + default_bg_color_calculator = QColor(214, 214, 214) # Greyish-White + sxinfo_widget_bg_color = QColor(0, 0, 0, 10) # Almost-Completely Transparent + sxcmd_widget_bg_color = QColor(0, 0, 0, 0) # Completely Transparent + sxcmd_tab_bg_color = QColor(229, 229, 229, 200) # White Transparent + sxcmd_tab_bg_color_string = 'rgba(229, 229, 229, 200)' # White Transparent # Constants project_dir_raw = "sxgui_settings" project_dir = project_dir_raw sxmain_window_left = 0 sxmain_window_top = 0 - sxmain_window_min_width = 1500 # Requirement of specification - sxmain_window_min_height = 360 # Requirement of specification + sxmain_window_min_width = 1500 # Requirement of specification + sxmain_window_min_height = 360 # Requirement of specification expected_cmd_counts = 32 - grid_margin = 6 # grid_margin = 12 + grid_margin = 6 # grid_margin = 12 grid_spacing = 6 # Constants initialised with invalid values. @@ -343,40 +359,43 @@ class SXLookFeelConst(object): sxcmd_widget_area_min_width = -1 file_dialog_dir = "" - + @staticmethod def initialise(sxapp, version): # Set the directory for all file dialogs to script directory version_main = ".".join(version.split('.')[:2]) SXLookFeelConst.project_dir += '/{0}'.format(version_main) SXLookFeelConst.file_dialog_dir = os.getcwd() - + # Check whether current settings directory exists if os.path.exists(SXLookFeelConst.project_dir): current_settings_exist = True else: current_settings_exist = False - + do_longer_warning = False older_settings_exist = False print('\nCurrent SPHIRE settings directory: {}'.format(SXLookFeelConst.project_dir)) try: for file_name in os.listdir(SXLookFeelConst.project_dir_raw): if file_name != os.path.basename(SXLookFeelConst.project_dir): - print('INFORMATION: Old settings directory %s/%s detected that belongs to another version of SPHIRE.' % (SXLookFeelConst.project_dir_raw, file_name)) + print( + 'INFORMATION: Old settings directory %s/%s detected that belongs to another version of SPHIRE.' % ( + SXLookFeelConst.project_dir_raw, file_name)) older_settings_exist = True if not current_settings_exist: do_longer_warning = True except FileNotFoundError: pass - + if do_longer_warning: print('To load old settings, please load the gui settings manually.') print('Backwards compatibility cannot be guaranteed.') - + if not current_settings_exist and not older_settings_exist: - print("\nSettings directory for current SPHIRE version %s doesn't exist\nWould you like to create a new project directory and continue?\nYou need to run the sphire command in the foreground (without &) to answer this question\n[y/n] "% SXLookFeelConst.project_dir) + print( + "\nSettings directory for current SPHIRE version %s doesn't exist\nWould you like to create a new project directory and continue?\nYou need to run the sphire command in the foreground (without &) to answer this question\n[y/n] " % SXLookFeelConst.project_dir) answer = input() while answer.lower() not in ('y', 'n'): print('Answer needs to be y or n') @@ -384,7 +403,7 @@ def initialise(sxapp, version): if answer.lower() == 'n': print("\nbye bye") exit() - + monitor_index = 0 # Search for maximum screen height and set it to SXLookFeelConst singleton class max_screen_height = sxapp.desktop().screenGeometry().height() @@ -426,18 +445,19 @@ def format_path(path): # use absolute path formatted_path = path # else: - # if the path is project subdirectory - # use relative path + # if the path is project subdirectory + # use relative path return formatted_path @staticmethod - def generate_sxcmd_wiki_url(sxcmd, wiki_type = "SPHIRE"): + def generate_sxcmd_wiki_url(sxcmd, wiki_type="SPHIRE"): if wiki_type == "SPHIRE": # First, handle exceptional cases if sxcmd.name in ["e2display", "sxpdb2em", "sxrelion2sphire", "sxprocess", "e2proc3d", "sxheader", "e2bdb"]: sxcmd_category_name = "utilities" - elif sxcmd.name in ["sxpipe"] and sxcmd.subname in ["resample_micrographs", "organize_micrographs", "restacking", "moon_eliminator"]: + elif sxcmd.name in ["sxpipe"] and sxcmd.subname in ["resample_micrographs", "organize_micrographs", + "restacking", "moon_eliminator"]: sxcmd_category_name = "utilities" # elif sxcmd.name in ["sxpipe"] and sxcmd.subname in ["reboxing"]: # sxcmd_category_name = "meridien" @@ -456,7 +476,7 @@ def generate_sxcmd_wiki_url(sxcmd, wiki_type = "SPHIRE"): sxcmd_wiki_url = "%s%s" % (SPARX_DOCUMENTATION_WEBSITE, sxcmd.name) if sxcmd.subname != "": sxcmd_wiki_url = "%s_%s" % (sxcmd_wiki_url, sxcmd.subname) - + return sxcmd_wiki_url @staticmethod @@ -467,14 +487,16 @@ def generate_sxmenu_item_wiki_url(sxmenu_item): sxmenu_item_wiki_url = "http://sphire.mpg.de/wiki/doku.php?id=start" else: # URL Format: "http://sphire.mpg.de/wiki/doku.php?id=pipeline:CMD_CATEGORY:start" - sxmenu_item_wiki_url = "http://sphire.mpg.de/wiki/doku.php?id=pipeline:%s:start" % (sxmenu_item.name.replace("sxc_", "")) + sxmenu_item_wiki_url = "http://sphire.mpg.de/wiki/doku.php?id=pipeline:%s:start" % ( + sxmenu_item.name.replace("sxc_", "")) assert (sxmenu_item_wiki_url is not None) - + return sxmenu_item_wiki_url + # ======================================================================================== class SXLogoButton(QPushButton): - def __init__(self, logo_file_path, parent = None): + def __init__(self, logo_file_path, parent=None): super(SXLogoButton, self).__init__(parent) # print "MRK_DEBUG: logo_file_path = %s" % logo_file_path @@ -502,9 +524,10 @@ def __init__(self, logo_file_path, parent = None): # Add ToolTip self.setToolTip('HELP') + # ======================================================================================== class SXPictogramButton(QPushButton): - def __init__(self, pictogram_name, pictogram_file_path, parent = None): + def __init__(self, pictogram_name, pictogram_file_path, parent=None): super(SXPictogramButton, self).__init__(parent) # print "MRK_DEBUG: pictogram_file_path = %s" % pictogram_file_path @@ -532,8 +555,9 @@ def __init__(self, pictogram_name, pictogram_file_path, parent = None): # Add tooltipp self.setToolTip(pictogram_name.upper()) + class SXMenuItemBtnAreaWidget(QWidget): - def __init__(self, sxconst_set, sxcmd_category_list, sxinfo, helical, parent = None): + def __init__(self, sxconst_set, sxcmd_category_list, sxinfo, helical, parent=None): super(SXMenuItemBtnAreaWidget, self).__init__(parent) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -549,7 +573,7 @@ def __init__(self, sxconst_set, sxcmd_category_list, sxinfo, helical, parent = N for sxcmd_category in sxcmd_category_list: if sxcmd_category.name != "sxc_utilities" and sxcmd_category.name != "sxc_movie": self.add_sxmenu_item_btn_widget(sxcmd_category, sxcmd_category_btn_subarea_widget) - else: # assert(sxcmd_category.name == "sxc_utilities") + else: # assert(sxcmd_category.name == "sxc_utilities") self.add_sxmenu_item_btn_widget(sxcmd_category, misc_func_btn_subarea_widget) global_layout = QVBoxLayout() @@ -557,7 +581,8 @@ def __init__(self, sxconst_set, sxcmd_category_list, sxinfo, helical, parent = N sxmenu_item_btn_area_widget = QWidget(self) sxmenu_item_btn_area_widget.setObjectName('SXMenuItemBtnAreaWidget') - sxmenu_item_btn_area_widget.setStyleSheet('QWidget#SXMenuItemBtnAreaWidget {background-color: rgba(0, 0, 0, 153);}') + sxmenu_item_btn_area_widget.setStyleSheet( + 'QWidget#SXMenuItemBtnAreaWidget {background-color: rgba(0, 0, 0, 153);}') sxmenu_item_btn_area_widget.setFixedWidth(SXLookFeelConst.sxmenu_btn_area_min_width) sxmenu_item_btn_area_layout = QVBoxLayout() @@ -611,13 +636,17 @@ def create_sxmenu_item_btn_subarea_widget(self): return sxmenu_item_btn_subarea_widget def add_sxmenu_item_btn_widget(self, sxmenu_item, sxmenu_item_btn_subarea_widget): - assert(isinstance(sxmenu_item, SXmenu_item) == True) # Assuming the sxmenu_item is an instance of class SXmenu_item - - sxmenu_item_btn_pictograph_file_path = sp_get_image_path(f'sxgui_pictograph_{sxmenu_item.name.replace("sxc_", "")}.png') + assert (isinstance(sxmenu_item, + SXmenu_item) == True) # Assuming the sxmenu_item is an instance of class SXmenu_item - sxmenu_item.btn = SXPictogramButton(sxmenu_item.name.replace("sxc_", ""), sxmenu_item_btn_pictograph_file_path, self) + sxmenu_item_btn_pictograph_file_path = sp_get_image_path( + f'sxgui_pictograph_{sxmenu_item.name.replace("sxc_", "")}.png') + sxmenu_item.btn = SXPictogramButton(sxmenu_item.name.replace("sxc_", ""), sxmenu_item_btn_pictograph_file_path, + self) cur_widget_counts = sxmenu_item_btn_subarea_widget.layout().count() - sxmenu_item_btn_subarea_widget.layout().addWidget(sxmenu_item.btn, cur_widget_counts // 2, cur_widget_counts % 2) + sxmenu_item_btn_subarea_widget.layout().addWidget(sxmenu_item.btn, cur_widget_counts // 2, + cur_widget_counts % 2) + # ======================================================================================== # Provides all necessary functionarity @@ -625,7 +654,7 @@ def add_sxmenu_item_btn_widget(self, sxmenu_item, sxmenu_item_btn_subarea_widget class SXCmdWidget(QWidget): ### process_started = pyqtSignal() - def __init__(self, sxconst_set, sxcmd, helical, parent = None): + def __init__(self, sxconst_set, sxcmd, helical, parent=None): super(SXCmdWidget, self).__init__(parent) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -638,7 +667,9 @@ def __init__(self, sxconst_set, sxcmd, helical, parent = None): self.child_application_list = [] - self.gui_settings_file_path = "%s/gui_settings_%s_%d.txt" % (self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir), self.sxcmd.get_mode_name_for("file_path"), int(helical)) + self.gui_settings_file_path = "%s/gui_settings_%s_%d.txt" % ( + self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir), self.sxcmd.get_mode_name_for("file_path"), + int(helical)) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -672,7 +703,6 @@ def __init__(self, sxconst_set, sxcmd, helical, parent = None): self.sxcmd.token_dict[key].widget.setText('0000000000000000099999') self.sxcmd.token_dict[key].widget.setText(text) - tab_widget = QTabWidget() tab_widget.insertTab(0, self.sxcmd_tab_main, self.sxcmd_tab_main.name) tab_widget.insertTab(1, self.sxcmd_tab_advance, self.sxcmd_tab_advance.name) @@ -726,7 +756,7 @@ def change_state(self, dependency, state, old_dependency=None, sender=None, prev None """ - #print(dependency, state, old_dependency) + # print(dependency, state, old_dependency) if sender is None: sender = self.sender() else: @@ -800,57 +830,56 @@ def change_state(self, dependency, state, old_dependency=None, sender=None, prev if not name in old_dependency: self.change_state(name, exp_state, old_dependency=old_dependency, sender=widget, prev_sender=sender) - #try: - # for name, exp_state, inverse in parent.sxcmd.dependency_dict[str(dependency)]: - # if not parent.sxcmd.token_dict[str(dependency)].widget.isEnabled(): - # is_enabled = False - # elif str(type_check(state)) != exp_state and inverse == 'True': - # is_enabled = True - # elif str(type_check(state)) == exp_state and inverse == 'True': - # is_enabled = False - # elif str(type_check(state)) == exp_state: - # is_enabled = True - # else: - # is_enabled = False - # print('STATE', name, exp_state, state, is_enabled, type_check, sender) - # SXCmdTab.set_text_entry_widget_enable_state(parent.sxcmd.token_dict[name].widget, is_enabled) - # child_dict = {} - # for name, exp_state, inverse in parent.sxcmd.dependency_dict[str(dependency)]: - # for entry in parent.sxcmd.token_dict[name].dependency_group: - # if not entry[0]: - # continue - # if name not in old_dependency and str(dependency) != entry[0]: - # try: - # new_state = parent.sxcmd.token_dict[name].widget.checkState() - # except AttributeError: - # new_state = parent.sxcmd.token_dict[name].widget.text() - # child_dict[name] = new_state - # for key, value in child_dict.items(): - # print(key, value) - # self.change_state(key, value, old_dependency, parent.sxcmd.token_dict[key].widget) - #except KeyError: - # return None - #print(state) - #try: - # for entry in self.cmd[name]: - # widget = entry[0] - # state = entry[1] - # sub_name = entry[2] - # if not self.content[name].isEnabled(): - # widget.setEnabled(False) - # elif self.content[name].edit.currentText() == state: - # widget.setEnabled(True) - # else: - # widget.setEnabled(False) - # self.change_state(name=sub_name) - #except KeyError: - # return None - + # try: + # for name, exp_state, inverse in parent.sxcmd.dependency_dict[str(dependency)]: + # if not parent.sxcmd.token_dict[str(dependency)].widget.isEnabled(): + # is_enabled = False + # elif str(type_check(state)) != exp_state and inverse == 'True': + # is_enabled = True + # elif str(type_check(state)) == exp_state and inverse == 'True': + # is_enabled = False + # elif str(type_check(state)) == exp_state: + # is_enabled = True + # else: + # is_enabled = False + # print('STATE', name, exp_state, state, is_enabled, type_check, sender) + # SXCmdTab.set_text_entry_widget_enable_state(parent.sxcmd.token_dict[name].widget, is_enabled) + # child_dict = {} + # for name, exp_state, inverse in parent.sxcmd.dependency_dict[str(dependency)]: + # for entry in parent.sxcmd.token_dict[name].dependency_group: + # if not entry[0]: + # continue + # if name not in old_dependency and str(dependency) != entry[0]: + # try: + # new_state = parent.sxcmd.token_dict[name].widget.checkState() + # except AttributeError: + # new_state = parent.sxcmd.token_dict[name].widget.text() + # child_dict[name] = new_state + # for key, value in child_dict.items(): + # print(key, value) + # self.change_state(key, value, old_dependency, parent.sxcmd.token_dict[key].widget) + # except KeyError: + # return None + # print(state) + # try: + # for entry in self.cmd[name]: + # widget = entry[0] + # state = entry[1] + # sub_name = entry[2] + # if not self.content[name].isEnabled(): + # widget.setEnabled(False) + # elif self.content[name].edit.currentText() == state: + # widget.setEnabled(True) + # else: + # widget.setEnabled(False) + # self.change_state(name=sub_name) + # except KeyError: + # return None def map_widgets_to_sxcmd_line(self): # Add program name to command line sxcmd_line = "%s.py" % (self.sxcmd.name) - + if self.sxcmd.subname != "": sxcmd_line += " %s" % (self.sxcmd.subname) @@ -879,15 +908,18 @@ def map_widgets_to_sxcmd_line(self): if external_file_path not in ["", sxcmd_token.default[external_file_path_index]]: # Case 1: User specified an exteranl function different from default or empty string if os.path.splitext(external_file_path)[1] != ".py": - QMessageBox.warning(self, "Invalid parameter value", "Exteranl File Path (%s) should include the python script extension (.py)." % (external_file_path)) + QMessageBox.warning(self, "Invalid parameter value", + "Exteranl File Path (%s) should include the python script extension (.py)." % ( + external_file_path)) return "" dir_path, file_basename = os.path.split(external_file_path) file_basename = file_basename.replace(".py", "") - sxcmd_line += " %s%s=[%s,%s,%s]" % (sxcmd_token.key_prefix, sxcmd_token.key_base, dir_path, file_basename, user_func_name) + sxcmd_line += " %s%s=[%s,%s,%s]" % ( + sxcmd_token.key_prefix, sxcmd_token.key_base, dir_path, file_basename, user_func_name) elif user_func_name != sxcmd_token.default[user_func_name_index]: # Case 2: User specified an internal function different from default sxcmd_line += " %s%s=%s" % (sxcmd_token.key_prefix, sxcmd_token.key_base, user_func_name) - # else: User left default value. Do nothing + # else: User left default value. Do nothing # Then, handle the other cases// else: if sxcmd_token.type == "bool_ignore": @@ -896,71 +928,81 @@ def map_widgets_to_sxcmd_line(self): ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == False: # Add this token to command line ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line - ### + ### ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == False: # Add this token to command line - ### - #else: # Do not add this token to command line + ### + # else: # Do not add this token to command line continue - + elif sxcmd_token.type == "bool": ### Possbile cases: ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == False: # Add this token to command line ### if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line - ### + ### ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line ### if sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default and sxcmd_token.is_required == False: # Add this token to command line - ### + ### is_flag_required = False if sxcmd_token.is_required: is_flag_required = True else: assert (not sxcmd_token.is_required) - if not sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default: + if not sxcmd_token.is_reversed and ( + sxcmd_token.widget.checkState() == Qt.Checked) != sxcmd_token.default: is_flag_required = True - elif sxcmd_token.is_reversed and (sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default: + elif sxcmd_token.is_reversed and ( + sxcmd_token.widget.checkState() == Qt.Checked) == sxcmd_token.default: is_flag_required = True else: assert (not is_flag_required) - + if is_flag_required: sxcmd_line += " %s%s" % (sxcmd_token.key_prefix, sxcmd_token.key_base) - #else: # Do not add this token to command line - + # else: # Do not add this token to command line + else: if sxcmd_token.widget.text() == sxcmd_token.default: ### if sxcmd_token.widget.text() == sxcmd_token.default and sxcmd_token.is_required == True: # Error case if sxcmd_token.is_required == True: - QMessageBox.warning(self, "Invalid parameter value", "Token (%s) of command (%s) is required. Please set the value for this." % (sxcmd_token.label, self.sxcmd.get_mode_name_for("human"))) + QMessageBox.warning(self, "Invalid parameter value", + "Token (%s) of command (%s) is required. Please set the value for this." % ( + sxcmd_token.label, self.sxcmd.get_mode_name_for("human"))) return "" - ### if sxcmd_token.widget.text() == sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line - # else: # assert(sxcmd_token.is_required == False) # Do not add to this command line - else: # sxcmd_token.widget.text() != sxcmd_token.default + ### if sxcmd_token.widget.text() == sxcmd_token.default and sxcmd_token.is_required == False: # Do not add this token to command line + # else: # assert(sxcmd_token.is_required == False) # Do not add to this command line + else: # sxcmd_token.widget.text() != sxcmd_token.default ### if sxcmd_token.widget.text() != sxcmd_token.default and sxcmd_token.is_required == True: # Add this token to command line ### if sxcmd_token.widget.text() != sxcmd_token.default and sxcmd_token.is_required == False: # Add this token to command line # For now, using line edit box for the other type widget_text = str(sxcmd_token.widget.text()) -### if sxcmd_token.type not in ["int", "float", "apix", "ctfwin", "box", "radius", "mass", "displayable_list", "mic_one_list", "any_file_list", "any_image_list", "dir_list"]: - if sxcmd_token.type not in ["int", "float", "abs_freq", "apix", "ctfwin", "box", "radius", "mass", "displayable_list", "mic_one_list", "dir_list", "filament_width"]: + ### if sxcmd_token.type not in ["int", "float", "apix", "ctfwin", "box", "radius", "mass", "displayable_list", "mic_one_list", "any_file_list", "any_image_list", "dir_list"]: + if sxcmd_token.type not in ["int", "float", "abs_freq", "apix", "ctfwin", "box", "radius", + "mass", "displayable_list", "mic_one_list", "dir_list", + "filament_width"]: # Always enclose the string value with single quotes (') widget_text = widget_text.strip("\'") # make sure the string is not enclosed by (') widget_text = widget_text.strip("\"") # make sure the string is not enclosed by (") - widget_text = "\'%s\'" % (widget_text) # then, enclose the string value with single quotes (') + widget_text = "\'%s\'" % ( + widget_text) # then, enclose the string value with single quotes (') if sxcmd_token.key_prefix == "": sxcmd_line += " %s" % (widget_text) elif sxcmd_token.key_prefix == "--": sxcmd_line += " %s%s=%s" % (sxcmd_token.key_prefix, sxcmd_token.key_base, widget_text) else: - ERROR("Logical Error: Encountered unexpected prefix for token (%s) of command (%s). Consult with the developer." % (sxcmd_token.key_base, self.sxcmd.get_mode_name_for("human")), "%s in %s" % (__name__, os.path.basename(__file__))) - # else: # assert(sxcmd_token.widget.text() == sxcmd_token.default) # Do not add to this command line + ERROR( + "Logical Error: Encountered unexpected prefix for token (%s) of command (%s). Consult with the developer." % ( + sxcmd_token.key_base, self.sxcmd.get_mode_name_for("human")), + "%s in %s" % (__name__, os.path.basename(__file__))) + # else: # assert(sxcmd_token.widget.text() == sxcmd_token.default) # Do not add to this command line return sxcmd_line @@ -1001,9 +1043,10 @@ def generate_cmd_line(self): if required_key_base != None: required_divisor = int(str(self.sxcmd.token_dict[required_key_base].widget.text())) - required_label = self.sxcmd.token_dict[required_key_base].label + required_label = self.sxcmd.token_dict[required_key_base].label if required_divisor == 0: - QMessageBox.warning(self, "Invalid parameter value", "\"%s\" must be larger than 0. Please check the setting" % (required_label)) + QMessageBox.warning(self, "Invalid parameter value", + "\"%s\" must be larger than 0. Please check the setting" % (required_label)) return "" valid_np = np @@ -1012,7 +1055,9 @@ def generate_cmd_line(self): valid_np = required_divisor else: valid_np = valid_np - (valid_np % required_divisor) - QMessageBox.warning(self, "Invalid parameter value", "The number of \"MPI processes\" (%d) is invalid. It MUST BE multiplicity of \"%s\" (%d). Please check the setting. A close valid number is %d." % (np, required_label, required_divisor,valid_np)) + QMessageBox.warning(self, "Invalid parameter value", + "The number of \"MPI processes\" (%d) is invalid. It MUST BE multiplicity of \"%s\" (%d). Please check the setting. A close valid number is %d." % ( + np, required_label, required_divisor, valid_np)) return "" # else: assert(np == 1) # because the "MPI Processes" is disabled for sx*.py process which does not support mpi @@ -1023,10 +1068,12 @@ def generate_cmd_line(self): # Case 1: queue submission is enabled (MPI can be supported or unsupported) # Create script for queue submission from a give template if os.path.exists(self.sxcmd_tab_main.qsub_script_edit.text()) != True: - QMessageBox.warning(self, "Invalid parameter value", "Invalid file path for qsub script template (%s)." % (self.sxcmd_tab_main.qsub_script_edit.text())) + QMessageBox.warning(self, "Invalid parameter value", + "Invalid file path for qsub script template (%s)." % ( + self.sxcmd_tab_main.qsub_script_edit.text())) return "" - file_template = open(self.sxcmd_tab_main.qsub_script_edit.text(),"r") + file_template = open(self.sxcmd_tab_main.qsub_script_edit.text(), "r") # Extract command line from qsub script template for line in file_template: if line.find("XXX_SXCMD_LINE_XXX") != -1: @@ -1038,11 +1085,14 @@ def generate_cmd_line(self): if cmd_line.find("XXX_SXMPI_NPROC_XXX") != -1: cmd_line = cmd_line.replace("XXX_SXMPI_NPROC_XXX", str(np)) if cmd_line.find("XXX_SXMPI_JOB_NAME_XXX") != -1: - cmd_line = cmd_line.replace("XXX_SXMPI_JOB_NAME_XXX", str(self.sxcmd_tab_main.qsub_job_name_edit.text())) + cmd_line = cmd_line.replace("XXX_SXMPI_JOB_NAME_XXX", + str(self.sxcmd_tab_main.qsub_job_name_edit.text())) file_template.close() elif self.sxcmd.mpi_support: # Case 2: queue submission is disabled, but MPI is supported - if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR("Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", "%s in %s" % (__name__, os.path.basename(__file__))) + if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR( + "Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", + "%s in %s" % (__name__, os.path.basename(__file__))) # Add MPI execution to command line cmd_line = str(self.sxcmd_tab_main.mpi_cmd_line_edit.text()) # If empty string is entered, use a default template @@ -1057,7 +1107,9 @@ def generate_cmd_line(self): cmd_line = cmd_line.replace("XXX_SXCMD_LINE_XXX", sxcmd_line) else: # Case 3: queue submission is disabled, and MPI is not supported - if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR("Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", "%s in %s" % (__name__, os.path.basename(__file__))) + if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR( + "Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", + "%s in %s" % (__name__, os.path.basename(__file__))) # Use sx command as it is cmd_line = sxcmd_line else: @@ -1085,13 +1137,18 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): # DESIGN_NOTE: 2015/11/24 Toshio Moriya # This special case needs to be handled with more general method... if sxcmd_token.type == "output_continue": - reply = QMessageBox.question(self, "Output Directory/File", "Output Directory/File (%s) already exists. Do you really want to run the program with continue mode?" % (sxcmd_token.widget.text()), QMessageBox.Yes | QMessageBox.No, QMessageBox.No) + reply = QMessageBox.question(self, "Output Directory/File", + "Output Directory/File (%s) already exists. Do you really want to run the program with continue mode?" % ( + sxcmd_token.widget.text()), + QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if reply == QMessageBox.No: return - # else: # Do nothing + # else: # Do nothing else: - assert(sxcmd_token.type == "output" or sxcmd_token.type == "output_bdb2d_stack") - QMessageBox.warning(self, "Output Directory/File", "Output Directory/File (%s) already exists. Please change the name and try it again. Aborting execution ..." % (sxcmd_token.widget.text())) + assert (sxcmd_token.type == "output" or sxcmd_token.type == "output_bdb2d_stack") + QMessageBox.warning(self, "Output Directory/File", + "Output Directory/File (%s) already exists. Please change the name and try it again. Aborting execution ..." % ( + sxcmd_token.widget.text())) return # If mpi is not supported set number of MPI processer (np) to 1 @@ -1102,18 +1159,23 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: # Case 1: queue submission is enabled (MPI can be supported or unsupported) # Create script for queue submission from a give template - submit_command_prefix = str(self.sxcmd_tab_main.qsub_cmd_edit.text()).split()[0]+"_" + submit_command_prefix = str(self.sxcmd_tab_main.qsub_cmd_edit.text()).split()[0] + "_" template_file_path = self.sxcmd_tab_main.qsub_script_edit.text() if os.path.exists(template_file_path) == False: - QMessageBox.warning(self, "Invalid parameter value", "Invalid file path for qsub script template (%s). Aborting execution ..." % (template_file_path)) + QMessageBox.warning(self, "Invalid parameter value", + "Invalid file path for qsub script template (%s). Aborting execution ..." % ( + template_file_path)) return - file_template = open(self.sxcmd_tab_main.qsub_script_edit.text(),"r") + file_template = open(self.sxcmd_tab_main.qsub_script_edit.text(), "r") if number is not None: - file_name_qsub_script = os.path.join(output_dir, "{0:04d}_".format(number) + submit_command_prefix + str(self.sxcmd_tab_main.qsub_job_name_edit.text()) + ".sh") + file_name_qsub_script = os.path.join(output_dir, + "{0:04d}_".format(number) + submit_command_prefix + str( + self.sxcmd_tab_main.qsub_job_name_edit.text()) + ".sh") else: - file_name_qsub_script = os.path.join(output_dir, submit_command_prefix + str(self.sxcmd_tab_main.qsub_job_name_edit.text()) + ".sh") - file_qsub_script = open(file_name_qsub_script,"w") + file_name_qsub_script = os.path.join(output_dir, submit_command_prefix + str( + self.sxcmd_tab_main.qsub_job_name_edit.text()) + ".sh") + file_qsub_script = open(file_name_qsub_script, "w") for line_io in file_template: if line_io.find("XXX_SXCMD_LINE_XXX") != -1: line_io = cmd_line @@ -1121,7 +1183,8 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): if line_io.find("XXX_SXMPI_NPROC_XXX") != -1: line_io = line_io.replace("XXX_SXMPI_NPROC_XXX", str(np)) if line_io.find("XXX_SXMPI_JOB_NAME_XXX") != -1: - line_io = line_io.replace("XXX_SXMPI_JOB_NAME_XXX", str(self.sxcmd_tab_main.qsub_job_name_edit.text())) + line_io = line_io.replace("XXX_SXMPI_JOB_NAME_XXX", + str(self.sxcmd_tab_main.qsub_job_name_edit.text())) file_qsub_script.write(line_io) file_template.close() file_qsub_script.close() @@ -1137,11 +1200,14 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): print("Saved command to: ") print(file_name_qsub_script) elif self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Unchecked and not execute: - QMessageBox.warning(self, "Qsub template needs to be specified for pipeline option", "Qsub template needs to be specified for pipeline option") + QMessageBox.warning(self, "Qsub template needs to be specified for pipeline option", + "Qsub template needs to be specified for pipeline option") return else: # Case 2: queue submission is disabled (MPI can be supported or unsupported) - if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR("Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", "%s in %s" % (__name__, os.path.basename(__file__))) + if self.sxcmd_tab_main.qsub_enable_checkbox.checkState() == Qt.Checked: ERROR( + "Logical Error: Encountered unexpected condition for sxcmd_tab_main.qsub_enable_checkbox.checkState. Consult with the developer.", + "%s in %s" % (__name__, os.path.basename(__file__))) print("Executed the following command: ") print(cmd_line) @@ -1150,7 +1216,7 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): process = subprocess.Popen(cmd_line, shell=True) ### self.process_started.emit(process.pid) if self.sxcmd.is_submittable == False: - assert(self.sxcmd.mpi_support == False) + assert (self.sxcmd.mpi_support == False) # Register to This is a GUI application self.child_application_list.append(process) @@ -1158,10 +1224,13 @@ def execute_cmd_line(self, execute=True, output_dir='.', number=None): if os.path.exists(self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir)) == False: os.makedirs(self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir)) self.write_params(self.gui_settings_file_path) - # else: SX command line is be empty because an error happens in generate_cmd_line. Let's do nothing + + # else: SX command line is be empty because an error happens in generate_cmd_line. Let's do nothing def add_to_pipeline(self): - name = QtGui.QFileDialog.getExistingDirectory(self, 'Pipeline output directory', SXLookFeelConst.file_dialog_dir, options = QFileDialog.DontUseNativeDialog) + name = QtGui.QFileDialog.getExistingDirectory(self, 'Pipeline output directory', + SXLookFeelConst.file_dialog_dir, + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): dir_name = str(name[0]) else: @@ -1173,10 +1242,11 @@ def add_to_pipeline(self): try: number = number_match.match(file_name).group(1) except AttributeError: - QMessageBox.warning(self, "Invalid file in pipeline directory", "There is a file in the pipeline directory not starting with four digits. Abort...") + QMessageBox.warning(self, "Invalid file in pipeline directory", + "There is a file in the pipeline directory not starting with four digits. Abort...") return - self.execute_cmd_line(execute=False, output_dir=dir_name, number=int(number)+1) + self.execute_cmd_line(execute=False, output_dir=dir_name, number=int(number) + 1) def print_cmd_line(self): # Generate command line @@ -1185,13 +1255,14 @@ def print_cmd_line(self): message_line = "Generated the following command line:" print(message_line) print(cmd_line) - QtGui.QMessageBox.information(self, "Information","%s \n\n%s" % (message_line, cmd_line)) + QtGui.QMessageBox.information(self, "Information", "%s \n\n%s" % (message_line, cmd_line)) # Save the current state of GUI settings if os.path.exists(self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir)) == False: os.makedirs(self.sxcmd.get_category_dir_path(SXLookFeelConst.project_dir)) self.write_params(self.gui_settings_file_path) - # else: Do nothing + + # else: Do nothing def show_dialog_calculated_res(self): # Generate command line @@ -1199,12 +1270,12 @@ def show_dialog_calculated_res(self): fsc_plot.plot(*args) def write_params(self, file_path_out): - file_out = open(file_path_out,"w") + file_out = open(file_path_out, "w") # Write script name for consistency check upon loading file_out.write("@@@@@ %s gui settings - " % (self.sxcmd.get_mode_name_for("human"))) # file_out.write(EMANVERSION + " (CVS" + CVSDATESTAMP[6:-2] +")") - file_out.write(EMANVERSION + " (GITHUB: " + DATESTAMP +")" ) + file_out.write(EMANVERSION + " (GITHUB: " + DATESTAMP + ")") file_out.write(" @@@@@ \n") # Define list of (tab) groups @@ -1222,7 +1293,9 @@ def write_params(self, file_path_out): n_widgets = 2 for widget_index in range(n_widgets): val_str = str(cmd_token.widget[widget_index].text()) - file_out.write("<%s> %s (default %s) == %s \n" % (cmd_token.key_base, cmd_token.label[widget_index], cmd_token.default[widget_index], val_str)) + file_out.write("<%s> %s (default %s) == %s \n" % ( + cmd_token.key_base, cmd_token.label[widget_index], cmd_token.default[widget_index], + val_str)) # Then, handle the other cases else: val_str = "" @@ -1236,10 +1309,12 @@ def write_params(self, file_path_out): val_str = str(cmd_token.widget.text()) if cmd_token.is_required == False: - file_out.write("<%s> %s (default %s) == %s \n" % (cmd_token.key_base, cmd_token.label, cmd_token.default, val_str)) + file_out.write("<%s> %s (default %s) == %s \n" % ( + cmd_token.key_base, cmd_token.label, cmd_token.default, val_str)) else: - file_out.write("<%s> %s (default required %s) == %s \n" % (cmd_token.key_base, cmd_token.label, cmd_token.type, val_str)) - # else: do nothig + file_out.write("<%s> %s (default required %s) == %s \n" % ( + cmd_token.key_base, cmd_token.label, cmd_token.type, val_str)) + # else: do nothig # At the end of parameter file... # Write MPI parameters @@ -1258,7 +1333,7 @@ def write_params(self, file_path_out): file_out.close() def read_params(self, file_path_in): - file_in = open(file_path_in,"r") + file_in = open(file_path_in, "r") # Check if this parameter file is for this sx script line_in = file_in.readline() @@ -1280,9 +1355,9 @@ def read_params(self, file_path_in): elif label_in == "Submit Job to Queue": if val_str_in == "YES": self.sxcmd_tab_main.qsub_enable_checkbox.setChecked(Qt.Checked) - else: # assert(val_str_in == "NO") + else: # assert(val_str_in == "NO") self.sxcmd_tab_main.qsub_enable_checkbox.setChecked(Qt.Unchecked) - # self.sxcmd_tab_main.set_qsub_enable_state() # Somehow this place does not paint the text boxes upon application startup + # self.sxcmd_tab_main.set_qsub_enable_state() # Somehow this place does not paint the text boxes upon application startup elif label_in == "Job Name": self.sxcmd_tab_main.qsub_job_name_edit.setText(val_str_in) elif label_in == "Submission Command": @@ -1294,37 +1369,43 @@ def read_params(self, file_path_in): target_operator = "<" item_tail = label_in.find(target_operator) if item_tail != 0: - QMessageBox.warning(self, "Invalid Parameter File Format", "Command token entry should start from \"%s\" for key base name in line (%s) of file (%s). The format of this file might be corrupted. Please save the parameter file again." % (target_operator, line_in, file_path_in)) - label_in = label_in[item_tail + len(target_operator):].strip() # Get the rest of line + QMessageBox.warning(self, "Invalid Parameter File Format", + "Command token entry should start from \"%s\" for key base name in line (%s) of file (%s). The format of this file might be corrupted. Please save the parameter file again." % ( + target_operator, line_in, file_path_in)) + label_in = label_in[item_tail + len(target_operator):].strip() # Get the rest of line target_operator = ">" item_tail = label_in.find(target_operator) if item_tail == -1: - QMessageBox.warning(self, "Invalid Parameter File Format", "Command token entry should have \"%s\" closing key base name in line (%s) of file (%s). The format of this file might be corrupted. Please save the parameter file again." % (target_operator, line_in, file_path_in)) + QMessageBox.warning(self, "Invalid Parameter File Format", + "Command token entry should have \"%s\" closing key base name in line (%s) of file (%s). The format of this file might be corrupted. Please save the parameter file again." % ( + target_operator, line_in, file_path_in)) key_base = label_in[0:item_tail] # Get corresponding cmd_token if key_base not in list(self.sxcmd.token_dict.keys()): - QMessageBox.warning(self, "Invalid Parameter File Format", "Invalid base name of command token \"%s\" is found in line (%s) of file (%s). This parameter file might be incompatible with the current version. Please save the parameter file again." % (key_base, line_in, file_path_in)) + QMessageBox.warning(self, "Invalid Parameter File Format", + "Invalid base name of command token \"%s\" is found in line (%s) of file (%s). This parameter file might be incompatible with the current version. Please save the parameter file again." % ( + key_base, line_in, file_path_in)) else: cmd_token = self.sxcmd.token_dict[key_base] - if not cmd_token.is_locked: + if not cmd_token.is_locked: # First, handle very special cases if cmd_token.type == "user_func": cmd_token.widget[function_type_line_counter].setText(val_str_in) function_type_line_counter += 1 - function_type_line_counter %= n_function_type_lines # function have two line edit boxes + function_type_line_counter %= n_function_type_lines # function have two line edit boxes else: if cmd_token.type in ("bool", "bool_ignore"): # construct new widget(s) for this command token if val_str_in == "YES": cmd_token.widget.setChecked(Qt.Checked) - else: # val_str_in == "NO" + else: # val_str_in == "NO" cmd_token.widget.setChecked(Qt.Unchecked) # Then, handle the other cases else: # For now, use line edit box for the other type cmd_token.widget.setText(val_str_in) if cmd_token.type == "apix": - cmd_token_apix = cmd_token + cmd_token_apix = cmd_token if cmd_token_apix is not None: assert (cmd_token_apix.type == "apix") # if len(cmd_token_apix.other_dialog_list) > 0: @@ -1333,20 +1414,23 @@ def read_params(self, file_path_in): # print("MRK_DEBUG: cmd_token_apix.widget.text() := \"{}\"".format(cmd_token_apix.widget.text())) # print("MRK_DEBUG: len(cmd_token_apix.other_dialog_list) := \"{}\"".format(len(cmd_token_apix.other_dialog_list))) for sxcmd_token_apix_other_dialog in cmd_token_apix.other_dialog_list: - # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text())) - # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text())) - # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text())) + # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text())) + # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text())) + # print("MRK_DEBUG: BEFORE sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text())) sxcmd_token_apix_other_dialog.reflect_external_local_update_apix_and_abs_freq() - # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text())) - # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text())) - # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text())) + # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxconst_register_widget_apix.text())) + # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_apix.text())) + # print("MRK_DEBUG: AFTER sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text() := \"{}\"".format(sxcmd_token_apix_other_dialog.sxcmd_token_widget_abs_freq.text())) else: - QMessageBox.warning(self, "Fail to load parameters", "The specified file parameter file for %s could not be read." % self.sxcmd.get_mode_name_for("human")) + QMessageBox.warning(self, "Fail to load parameters", + "The specified file parameter file for %s could not be read." % self.sxcmd.get_mode_name_for( + "human")) file_in.close() def save_params(self): - name = QFileDialog.getSaveFileName(self, "Save Parameters", SXLookFeelConst.file_dialog_dir, options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getSaveFileName(self, "Save Parameters", SXLookFeelConst.file_dialog_dir, + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1355,7 +1439,8 @@ def save_params(self): self.write_params(file_path) def load_params(self): - name = QFileDialog.getOpenFileName(self, "Load parameters", SXLookFeelConst.file_dialog_dir, options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Load parameters", SXLookFeelConst.file_dialog_dir, + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1364,15 +1449,17 @@ def load_params(self): self.read_params(file_path) self.sxcmd_tab_main.set_qsub_enable_state() - def select_file(self, target_widget, file_format = ""): + def select_file(self, target_widget, file_format=""): file_path = "" # NOTE: Toshio Moriya 2018/01/25 # All supported image/volume formats according to http://blake.bcm.edu/emanwiki/EMAN2ImageFormats # ;; HDF (*.hdf);; MRC (*.mrc);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; TIFF (*.tif *.tiff);; PNG (*.png);; JPEG (*.jpg *.jpeg);; BDB (*.bdb);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.hdr *.img);; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor) - # + # if file_format == "displayable_list": # Read not supported: ;; JPEG (*.jpg *.jpeg) - name = QFileDialog.getOpenFileNames(self, "Select any displayable files", SXLookFeelConst.file_dialog_dir, "Typical displayable files (*.hdf *.bdb *.mrc *.mrcs *.spi *.img *.tif *.tiff *.png *.txt);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; TIFF (*.tif *.tiff);; PNG (*.png);; Text (*.txt);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.hdr *.img);; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileNames(self, "Select any displayable files", SXLookFeelConst.file_dialog_dir, + "Typical displayable files (*.hdf *.bdb *.mrc *.mrcs *.spi *.img *.tif *.tiff *.png *.txt);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; TIFF (*.tif *.tiff);; PNG (*.png);; Text (*.txt);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.hdr *.img);; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path_list = name[0] else: @@ -1380,14 +1467,17 @@ def select_file(self, target_widget, file_format = ""): for a_file_path in file_path_list: # Use relative path. a_file_path = str(SXLookFeelConst.format_path(a_file_path)) - try: # Check if the path is bdb - a_file_path = translate_to_bdb_path(a_file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + a_file_path = translate_to_bdb_path( + a_file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path file_path += a_file_path + " " elif file_format == "data2d3d_both": # Read not supported: ;; JPEG (*.jpg *.jpeg) - name = QFileDialog.getOpenFileName(self, "Select any image/volume file", SXLookFeelConst.file_dialog_dir, "Typical image & volume files (*.hdf *.bdb *.mrc *.mrcs *.spi *.img *.tif *.tiff *.png);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; TIFF (*.tif *.tiff);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.hdr *.img);; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any image/volume file", SXLookFeelConst.file_dialog_dir, + "Typical image & volume files (*.hdf *.bdb *.mrc *.mrcs *.spi *.img *.tif *.tiff *.png);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; TIFF (*.tif *.tiff);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.hdr *.img);; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1395,12 +1485,15 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "mrc2d_mic_both": - name = QFileDialog.getOpenFileName(self, "Select MRC micrograph/movie file", SXLookFeelConst.file_dialog_dir, "MRC micrograph & movie files (*.mrc *.mrcs);; MRC (*.mrc);; MRCS (*.mrcs)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select MRC micrograph/movie file", + SXLookFeelConst.file_dialog_dir, + "MRC micrograph & movie files (*.mrc *.mrcs);; MRC (*.mrc);; MRCS (*.mrcs)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1410,7 +1503,10 @@ def select_file(self, target_widget, file_format = ""): file_path = SXLookFeelConst.format_path(file_path) elif file_format == "mic_both": # Read not supported: ;; JPEG (*.jpg *.jpeg) - name = QFileDialog.getOpenFileName(self, "Select any micrograph/movie file", SXLookFeelConst.file_dialog_dir, "Typical micrograph & movie files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any micrograph/movie file", + SXLookFeelConst.file_dialog_dir, + "Typical micrograph & movie files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1418,12 +1514,14 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "mrc2d_mic_one": - name = QFileDialog.getOpenFileName(self, "Select MRC micrograph file", SXLookFeelConst.file_dialog_dir, "MRC micrograph files (*.mrc);; MRCS (*.mrcs)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select MRC micrograph file", SXLookFeelConst.file_dialog_dir, + "MRC micrograph files (*.mrc);; MRCS (*.mrcs)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1433,12 +1531,14 @@ def select_file(self, target_widget, file_format = ""): file_path = SXLookFeelConst.format_path(file_path) elif file_format == "mic_one": # NOTE: Toshio Moriya 2018/01/25 - # Currently, the distinction between MRC and MRCS is not always used, and + # Currently, the distinction between MRC and MRCS is not always used, and # MRC can be also micrograph stack dependes on external programs (e.g. unblur, summovie)... - # + # # Read not supported: ;; JPEG (*.jpg *.jpeg) # Only stack: ;; MRCS (*.mrcs) - name = QFileDialog.getOpenFileName(self, "Select any micrograph file", SXLookFeelConst.file_dialog_dir, "Typical micrograph files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any micrograph file", SXLookFeelConst.file_dialog_dir, + "Typical micrograph files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1446,16 +1546,18 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "mrc2d_mic_one_list": # NOTE: Toshio Moriya 2018/01/25 - # Currently, the distinction between MRC and MRCS is not always used, and + # Currently, the distinction between MRC and MRCS is not always used, and # MRC can be also micrograph stack dependes on external programs (e.g. unblur, summovie)... - # - name = QFileDialog.getOpenFileNames(self, "Select MRC micrograph files", SXLookFeelConst.file_dialog_dir, "MRC files (*.mrc);; MRCS (*.mrcs)", options = QFileDialog.DontUseNativeDialog) + # + name = QFileDialog.getOpenFileNames(self, "Select MRC micrograph files", SXLookFeelConst.file_dialog_dir, + "MRC files (*.mrc);; MRCS (*.mrcs)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path_list = name[0] else: @@ -1465,12 +1567,14 @@ def select_file(self, target_widget, file_format = ""): file_path += str(SXLookFeelConst.format_path(a_file_path)) + " " elif file_format == "mic_one_list": # NOTE: Toshio Moriya 2018/01/25 - # Currently, the distinction between MRC and MRCS is not always used, and + # Currently, the distinction between MRC and MRCS is not always used, and # MRC can be also micrograph stack dependes on external programs (e.g. unblur, summovie)... - # + # # Read not supported: ;; JPEG (*.jpg *.jpeg) # Only stack: ;; MRCS (*.mrcs) - name = QFileDialog.getOpenFileNames(self, "Select any micrograph files", SXLookFeelConst.file_dialog_dir, "Typical micrograph files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileNames(self, "Select any micrograph files", SXLookFeelConst.file_dialog_dir, + "Typical micrograph files (*.mrc *.mrcs *.tif *.tiff *.hdf *.bdb *.spi *.img);; MRC (*.mrc);; MRCS (*.mrcs);; TIFF (*.tif *.tiff);; HDF (*.hdf);; BDB (*.bdb);; Spider (*.spi);; Imagic (*.img);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path_list = name[0] else: @@ -1478,13 +1582,16 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. for a_file_path in file_path_list: a_file_path = str(SXLookFeelConst.format_path(a_file_path)) - try: # Check if the path is bdb - a_file_path = translate_to_bdb_path(a_file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + a_file_path = translate_to_bdb_path( + a_file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path file_path += a_file_path + " " elif file_format == "mrc2d_mic_stack": - name = QFileDialog.getOpenFileName(self, "Select MRC movie file", SXLookFeelConst.file_dialog_dir, "MRC movie files (*.mrcs);; MRC (*.mrc)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select MRC movie file", SXLookFeelConst.file_dialog_dir, + "MRC movie files (*.mrcs);; MRC (*.mrc)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1494,13 +1601,15 @@ def select_file(self, target_widget, file_format = ""): file_path = SXLookFeelConst.format_path(file_path) elif file_format == "mic_stack": # NOTE: Toshio Moriya 2018/01/25 - # Currently, the distinction between MRC and MRCS is not always used, and + # Currently, the distinction between MRC and MRCS is not always used, and # MRC can be also micrograph stack dependes on external programs (e.g. unblur, summovie)... - # + # # Read not supported: ;; JPEG (*.jpg *.jpeg) # 2D image stack not supported: ;; Gatan (*.dm2 *.dm3);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; OMAP (*.omap);; PGM (*.pgm);; PNG (*.png);; SAL (*.hdr *.img);; SITUS (*.situs);; TIFF (*.tif *.tiff);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor) # Maybe only single 2D image: ;; MRC (*.mrc) - name = QFileDialog.getOpenFileName(self, "Select any movie file", SXLookFeelConst.file_dialog_dir, "Typical movie files (*.mrcs *.mrc *.bdb *.hdf *.spi *.img );; MRCS (*.mrcs);; MRC (*.mrc);; BDB (*.bdb);; HDF (*.hdf);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any movie file", SXLookFeelConst.file_dialog_dir, + "Typical movie files (*.mrcs *.mrc *.bdb *.hdf *.spi *.img );; MRCS (*.mrcs);; MRC (*.mrc);; BDB (*.bdb);; HDF (*.hdf);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1508,12 +1617,13 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "hdf2d_one": - name = QFileDialog.getOpenFileName(self, "Select HDF image file", SXLookFeelConst.file_dialog_dir, "HDF image files (*.hdf)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select HDF image file", SXLookFeelConst.file_dialog_dir, + "HDF image files (*.hdf)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1524,7 +1634,9 @@ def select_file(self, target_widget, file_format = ""): elif file_format == "data2d_one": # Read not supported: ;; JPEG (*.jpg *.jpeg) # Maybe only 2D image stack: ;; MRCS (*.mrcs) - name = QFileDialog.getOpenFileName(self, "Select any image file", SXLookFeelConst.file_dialog_dir, "Typical image files (*.hdf *.bdb *.mrc *.spi *.img *.tif *.tiff *.png *.mrcs);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc *.mrcs);; Spider (*.spi);; Imagic (*.img);; TIFF (*.tif *.tiff);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any image file", SXLookFeelConst.file_dialog_dir, + "Typical image files (*.hdf *.bdb *.mrc *.spi *.img *.tif *.tiff *.png *.mrcs);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc *.mrcs);; Spider (*.spi);; Imagic (*.img);; TIFF (*.tif *.tiff);; PNG (*.png);; Gatan (*.dm2 *.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; SAL (*.img );; SITUS (*.situs);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1532,12 +1644,13 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "bdb2d_stack": - name = QFileDialog.getOpenFileName(self, "Select BDB image stack file", SXLookFeelConst.file_dialog_dir, "BDB files (*.bdb)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select BDB image stack file", SXLookFeelConst.file_dialog_dir, + "BDB files (*.bdb)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1551,7 +1664,9 @@ def select_file(self, target_widget, file_format = ""): # Read not supported: ;; JPEG (*.jpg *.jpeg) # 2D image stack not supported: ;; Gatan (*.dm2 *.dm3);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; OMAP (*.omap);; PGM (*.pgm);; PNG (*.png);; SAL (*.hdr *.img);; SITUS (*.situs);; TIFF (*.tif *.tiff);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor) # Maybe only single 2D image: ;; MRC (*.mrc) - name = QFileDialog.getOpenFileName(self, "Select any image stack file", SXLookFeelConst.file_dialog_dir, "Typical image stack files (*.bdb *.hdf *.mrcs *.spi *.img );; BDB (*.bdb);; HDF (*.hdf);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any image stack file", SXLookFeelConst.file_dialog_dir, + "Typical image stack files (*.star *.bdb *.hdf *.mrcs *.spi *.img );; STAR (*.star);; BDB (*.bdb);; HDF (*.hdf);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1559,12 +1674,13 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "hdf3d_one": - name = QFileDialog.getOpenFileName(self, "Select HDF volume file", SXLookFeelConst.file_dialog_dir, "HDF volume files (*.hdf)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select HDF volume file", SXLookFeelConst.file_dialog_dir, + "HDF volume files (*.hdf)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1576,7 +1692,9 @@ def select_file(self, target_widget, file_format = ""): # Read not supported: ;; JPEG (*.jpg *.jpeg) # 3D volume not supported: ;; Gatan (*.dm2 *.dm3);; FEI (*.ser);; SAL (*.hdr *.img);; PGM (*.pgm);; PNG (*.png);; TIFF (*.tif *.tiff);; V4L (*.v4l) # Maybe only 3D volume stack: ;; MRCS (*.mrcs) - name = QFileDialog.getOpenFileName(self, "Select any volume file", SXLookFeelConst.file_dialog_dir, "Typical volume files (*.hdf *.bdb *.mrc *.spi *.img);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; Spider (*.spi);; Imagic (*.img);; Gatan (*.dm4);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PIF (*.pif);; SITUS (*.situs);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any volume file", SXLookFeelConst.file_dialog_dir, + "Typical volume files (*.hdf *.bdb *.mrc *.spi *.img);; HDF (*.hdf);; BDB (*.bdb);; MRC (*.mrc);; Spider (*.spi);; Imagic (*.img);; Gatan (*.dm4);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PIF (*.pif);; SITUS (*.situs);; VTK (*.vtk);; XPLOR (*.xplor);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1584,15 +1702,17 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "hdf3d_stack": # NOTE: Toshio Moriya 2018/01/25 # Currently, this case is not used. - # - name = QFileDialog.getOpenFileName(self, "Select HDF volume stack file", SXLookFeelConst.file_dialog_dir, "HDF volume stack files (*.hdf)", options = QFileDialog.DontUseNativeDialog) + # + name = QFileDialog.getOpenFileName(self, "Select HDF volume stack file", SXLookFeelConst.file_dialog_dir, + "HDF volume stack files (*.hdf)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1603,12 +1723,14 @@ def select_file(self, target_widget, file_format = ""): elif file_format == "data3d_stack": # NOTE: Toshio Moriya 2018/01/25 # Currently, this case is not used. - # + # # Read not supported: ;; JPEG (*.jpg *.jpeg) # 3D volume stack not supported: ;; Gatan (*.dm2) # Maybe 3D volume stack not supported: ;; Gatan (*.dm3 *.dm4);; FEI (*.ser);; EM (*.em);; ICOS (*.icos);; Spider (*.spi);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; LST (*.lst);; LSTFAST (*.lsx *.lst);; OMAP (*.omap);; PGM (*.pgm);; PIF (*.pif);; PNG (*.png);; SAL (*.hdr *.img);; SITUS (*.situs);; TIFF (*.tif *.tiff);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor) # Maybe only sigle 3D volume: ;; MRC (*.mrc) - name = QFileDialog.getOpenFileName(self, "Select any volume stack file", SXLookFeelConst.file_dialog_dir, "Typical volume stack files (*.hdf *.bdb *.mrcs *.img);; HDF (*.hdf);; BDB (*.bdb);; MRCS (*.mrcs);; Imagic (*.img *hed);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any volume stack file", SXLookFeelConst.file_dialog_dir, + "Typical volume stack files (*.hdf *.bdb *.mrcs *.img);; HDF (*.hdf);; BDB (*.bdb);; MRCS (*.mrcs);; Imagic (*.img *hed);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1616,12 +1738,15 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) - try: # Check if the path is bdb - file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. + try: # Check if the path is bdb + file_path = translate_to_bdb_path(file_path) # Convert the standard path to bdb key if possible. except ValueError: # If the path is not bdb, we will receive this exception - pass # This is not bdb path. Then, use standard path + pass # This is not bdb path. Then, use standard path elif file_format == "select_mic_both": - name = QFileDialog.getOpenFileName(self, "Select micrograph/movie selection file", SXLookFeelConst.file_dialog_dir, "Micrograph/Movie selection files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select micrograph/movie selection file", + SXLookFeelConst.file_dialog_dir, + "Micrograph/Movie selection files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1630,7 +1755,10 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "select_mic_one": - name = QFileDialog.getOpenFileName(self, "Select micrograph selection file", SXLookFeelConst.file_dialog_dir, "Micrograph selection files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select micrograph selection file", + SXLookFeelConst.file_dialog_dir, + "Micrograph selection files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1639,7 +1767,10 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "select_mic_stack": - name = QFileDialog.getOpenFileName(self, "Select micrograph movie selection file", SXLookFeelConst.file_dialog_dir, "Micrograph movie selection files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select micrograph movie selection file", + SXLookFeelConst.file_dialog_dir, + "Micrograph movie selection files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1648,7 +1779,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "select_data2d_stack": - name = QFileDialog.getOpenFileName(self, "Select image selection file", SXLookFeelConst.file_dialog_dir, "Image selection files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select image selection file", SXLookFeelConst.file_dialog_dir, + "Image selection files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1657,7 +1790,10 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "select_drift_params": - name = QFileDialog.getOpenFileName(self, "Select drift shift params selection file", SXLookFeelConst.file_dialog_dir, "Drift shift params selection files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select drift shift params selection file", + SXLookFeelConst.file_dialog_dir, + "Drift shift params selection files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1666,7 +1802,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_any_txt": - name = QFileDialog.getOpenFileName(self, "Select parameters file", SXLookFeelConst.file_dialog_dir, "Parameters text files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select parameters file", SXLookFeelConst.file_dialog_dir, + "Parameters text files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1675,7 +1813,10 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_proj_txt": - name = QFileDialog.getOpenFileName(self, "Select projection parameters file", SXLookFeelConst.file_dialog_dir, "Projection parameters files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select projection parameters file", + SXLookFeelConst.file_dialog_dir, + "Projection parameters files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1684,7 +1825,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_coords_box": - name = QFileDialog.getOpenFileName(self, "Select EMAN BOX coordinates file", SXLookFeelConst.file_dialog_dir, "EMAN BOX coordinates files (*.box)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select EMAN BOX coordinates file", + SXLookFeelConst.file_dialog_dir, "EMAN BOX coordinates files (*.box)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1693,7 +1836,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_coords_any": - name = QFileDialog.getOpenFileName(self, "Select any coordinates file", SXLookFeelConst.file_dialog_dir, "Typical coordinates files (*.box *.json *.dat *.txt);; EMAN BOX (*.box);; EMAN2 JSON (*.json);; SPIDER DAT (*.dat);; SPHIRE TXT (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any coordinates file", SXLookFeelConst.file_dialog_dir, + "Typical coordinates files (*.box *.json *.dat *.txt);; EMAN BOX (*.box);; EMAN2 JSON (*.json);; SPIDER DAT (*.dat);; SPHIRE TXT (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1702,7 +1847,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_cter_txt": - name = QFileDialog.getOpenFileName(self, "Select CTER partres parameters file", SXLookFeelConst.file_dialog_dir, "CTER partres parameters files (*.txt)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select CTER partres parameters file", + SXLookFeelConst.file_dialog_dir, "CTER partres parameters files (*.txt)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1711,7 +1858,8 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_rebox_rbx": - name = QFileDialog.getOpenFileName(self, "Select SPHIRE rebox file", SXLookFeelConst.file_dialog_dir, "SPHIRE rebox files (*.rbx)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select SPHIRE rebox file", SXLookFeelConst.file_dialog_dir, + "SPHIRE rebox files (*.rbx)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1720,7 +1868,10 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_drift_txt": - name = QFileDialog.getOpenFileName(self, "Select drift shift parameters file", SXLookFeelConst.file_dialog_dir, "MotionCor2|cisTEM Unblur (*.log);;Drift shift parameters files (*.txt);;All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select drift shift parameters file", + SXLookFeelConst.file_dialog_dir, + "MotionCor2|cisTEM Unblur (*.log);;Drift shift parameters files (*.txt);;All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1729,7 +1880,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "rot_matrix": - name = QFileDialog.getOpenFileName(self, "Select rotational matrix file", SXLookFeelConst.file_dialog_dir, "Rotational matrix files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select rotational matrix file", SXLookFeelConst.file_dialog_dir, + "Rotational matrix files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1738,7 +1891,20 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_relion_star": - name = QFileDialog.getOpenFileName(self, "Select RELION STAR file", SXLookFeelConst.file_dialog_dir, "RELION STAR files (*.star);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select RELION STAR file", SXLookFeelConst.file_dialog_dir, + "RELION STAR files (*.star);; All files (*)", + options=QFileDialog.DontUseNativeDialog) + if isinstance(name, tuple): + file_path = str(name[0]) + else: + file_path = str(name) + # Use relative path. + if file_path: + file_path = SXLookFeelConst.format_path(file_path) + elif file_format == "params_star": + name = QFileDialog.getOpenFileName(self, "Select STAR file", SXLookFeelConst.file_dialog_dir, + "STAR files (*.star);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1747,7 +1913,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_any_json": - name = QFileDialog.getOpenFileName(self, "Select JSON file", SXLookFeelConst.file_dialog_dir, "JSON files (*.json);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select JSON file", SXLookFeelConst.file_dialog_dir, + "JSON files (*.json);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1756,7 +1924,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_any_h5": - name = QFileDialog.getOpenFileName(self, "Select h5 file", SXLookFeelConst.file_dialog_dir, "h5 files (*.h5);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select h5 file", SXLookFeelConst.file_dialog_dir, + "h5 files (*.h5);; All files (*)", + options=QFileDialog.DontUseNativeDialog) # Use relative path. if isinstance(name, tuple): file_path = str(name[0]) @@ -1765,7 +1935,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "spectrum1d": - name = QFileDialog.getOpenFileName(self, "Select 1D power spectrum file", SXLookFeelConst.file_dialog_dir, "1D power spectrum files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select 1D power spectrum file", SXLookFeelConst.file_dialog_dir, + "1D power spectrum files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1774,7 +1946,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "mtf": - name = QFileDialog.getOpenFileName(self, "Select MTF data file", SXLookFeelConst.file_dialog_dir, "MTF data files (*.txt);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select MTF data file", SXLookFeelConst.file_dialog_dir, + "MTF data files (*.txt);; All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1783,7 +1957,8 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "pdb": - name = QFileDialog.getOpenFileName(self, "Select PDB data file", SXLookFeelConst.file_dialog_dir, "PDB data files (*.pdb *.pdb*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select PDB data file", SXLookFeelConst.file_dialog_dir, + "PDB data files (*.pdb *.pdb*)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1792,7 +1967,9 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "exe": - name = QFileDialog.getOpenFileName(self, "Select executable file", SXLookFeelConst.file_dialog_dir, "All files (*);; Python (*.py) ;; Executable files (*.exe)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select executable file", SXLookFeelConst.file_dialog_dir, + "All files (*);; Python (*.py) ;; Executable files (*.exe)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1801,38 +1978,44 @@ def select_file(self, target_widget, file_format = ""): if file_path: file_path = SXLookFeelConst.format_path(file_path) elif file_format == "py": - name = QFileDialog.getOpenFileName(self, "Select Python script file", SXLookFeelConst.file_dialog_dir, "PY files (*.py)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select Python script file", SXLookFeelConst.file_dialog_dir, + "PY files (*.py)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: file_path = str(name) - # Use full path -### elif file_format == "bdb": -### file_path = QFileDialog.getOpenFileName(self, "Select BDB image file", SXLookFeelConst.file_dialog_dir, "BDB files (*.bdb)", options = QFileDialog.DontUseNativeDialog) -### # Use relative path. -### if file_path: -### file_path = SXLookFeelConst.format_path(file_path) -### file_path = translate_to_bdb_path(file_path) -### elif file_format == "any_file_list" or file_format == "any_image_list": -### file_path_list = QFileDialog.getOpenFileNames(self, "Select files", SXLookFeelConst.file_dialog_dir, "All files (*)", options = QFileDialog.DontUseNativeDialog) -### # Use relative path. -### for a_file_path in file_path_list: -### file_path += SXLookFeelConst.format_path(str(a_file_path)) + " " + # Use full path + ### elif file_format == "bdb": + ### file_path = QFileDialog.getOpenFileName(self, "Select BDB image file", SXLookFeelConst.file_dialog_dir, "BDB files (*.bdb)", options = QFileDialog.DontUseNativeDialog) + ### # Use relative path. + ### if file_path: + ### file_path = SXLookFeelConst.format_path(file_path) + ### file_path = translate_to_bdb_path(file_path) + ### elif file_format == "any_file_list" or file_format == "any_image_list": + ### file_path_list = QFileDialog.getOpenFileNames(self, "Select files", SXLookFeelConst.file_dialog_dir, "All files (*)", options = QFileDialog.DontUseNativeDialog) + ### # Use relative path. + ### for a_file_path in file_path_list: + ### file_path += SXLookFeelConst.format_path(str(a_file_path)) + " " elif file_format == 'submission_template': if 'SPHIRE_SUBMISSION_SCRIPT_TEMPLATE_FOLDER' in os.environ: template_folder = os.environ['SPHIRE_SUBMISSION_SCRIPT_TEMPLATE_FOLDER'] else: template_folder = SXLookFeelConst.file_dialog_dir - name = QFileDialog.getOpenFileName(self, "Select any file", template_folder, "All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any file", template_folder, "All files (*)", + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: file_path = str(name) else: if file_format: - name = QFileDialog.getOpenFileName(self, "Select %s file" % (file_format.upper()), SXLookFeelConst.file_dialog_dir, "%s files (*.%s)" % (file_format.upper(), file_format), options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select %s file" % (file_format.upper()), + SXLookFeelConst.file_dialog_dir, + "%s files (*.%s)" % (file_format.upper(), file_format), + options=QFileDialog.DontUseNativeDialog) else: - name = QFileDialog.getOpenFileName(self, "Select any file", SXLookFeelConst.file_dialog_dir, "All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any file", SXLookFeelConst.file_dialog_dir, + "All files (*)", options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1845,7 +2028,8 @@ def select_file(self, target_widget, file_format = ""): target_widget.setText(file_path) def select_dir(self, target_widget): - dir_path = QFileDialog.getExistingDirectory(self, "Select directory", SXLookFeelConst.file_dialog_dir, options = QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks | QFileDialog.DontUseNativeDialog) + dir_path = QFileDialog.getExistingDirectory(self, "Select directory", SXLookFeelConst.file_dialog_dir, + options=QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks | QFileDialog.DontUseNativeDialog) if dir_path != "": # Use relative path. target_widget.setText(SXLookFeelConst.format_path(dir_path)) @@ -1854,13 +2038,15 @@ def quit_all_child_applications(self): # Quit all child applications for child_application in self.child_application_list: child_application.kill() - # child_application.terminate() # This call ends up outputing "Program interrupted" Message and it is not pretty... + + # child_application.terminate() # This call ends up outputing "Program interrupted" Message and it is not pretty... """ # def show_output_info(self): # QMessageBox.information(self, "sx* output","outdir is the name of the output folder specified by the user. If it does not exist, the directory will be created. If it does exist, the program will crash and an error message will come up. Please change the name of directory and restart the program.") """ + class SXLineEdit(QtGui.QLineEdit): my_changed_state = QtCore.pyqtSignal(str, str) @@ -1897,27 +2083,34 @@ def __init__(self, name, helical, parent=None): default_cmd_token_restore_tooltip = "Retrieve this default value" # Setting for layout - grid_row_origin = 0; grid_col_origin = 0 - title_row_span = 1; title_col_span = 2 - short_info_row_span = 1; short_info_col_span = 5 - func_btn_row_span = 1; func_btn_col_span = 2 - token_label_row_span = 1; token_label_col_span = 4 - token_widget_row_span = 1; token_widget_col_span = 1.5 - cmd_frame_row_span = 32; cmd_frame_col_span = 7 - - title_label_min_width = 180 # title_label_min_width = 150 - title_label_min_height = 40 #title_label_min_height = 80 - short_info_min_width = 260 # short_info_min_width = 360 - short_info_min_height = 40 # short_info_min_height = 80 + grid_row_origin = 0; + grid_col_origin = 0 + title_row_span = 1; + title_col_span = 2 + short_info_row_span = 1; + short_info_col_span = 5 + func_btn_row_span = 1; + func_btn_col_span = 2 + token_label_row_span = 1; + token_label_col_span = 4 + token_widget_row_span = 1; + token_widget_col_span = 1.5 + cmd_frame_row_span = 32; + cmd_frame_col_span = 7 + + title_label_min_width = 180 # title_label_min_width = 150 + title_label_min_height = 40 # title_label_min_height = 80 + short_info_min_width = 260 # short_info_min_width = 360 + short_info_min_height = 40 # short_info_min_height = 80 func_btn_min_width = 150 btn_min_width = 300 - token_label_min_width = 300 # token_label_min_width = 360 + token_label_min_width = 300 # token_label_min_width = 360 token_widget_min_width = 120 mpi_label_min_width = 100 # Setup global layout global_layout = QVBoxLayout(self) - global_layout.setContentsMargins(0,0,0,0) + global_layout.setContentsMargins(0, 0, 0, 0) global_layout.setSpacing(0) # Setup scroll area and its widget scroll_area = QScrollArea() @@ -1940,32 +2133,42 @@ def __init__(self, name, helical, parent=None): # Setup other layouts scroll_layout = QVBoxLayout(scroll_area_widget) - scroll_layout.setContentsMargins(0,0,0,0) + scroll_layout.setContentsMargins(0, 0, 0, 0) title_hbox = QHBoxLayout() title_layout = QGridLayout() - title_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + title_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) title_layout.setSpacing(SXLookFeelConst.grid_spacing) -# title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span, token_widget_min_width) -# title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_min_width) -# title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_min_width) -# title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_min_width) + # title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span, token_widget_min_width) + # title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_min_width) + # title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_min_width) + # title_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_min_width) grid_layout = QGridLayout() - grid_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + grid_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) grid_layout.setSpacing(SXLookFeelConst.grid_spacing) grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span, token_widget_min_width) - grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_min_width) - grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_min_width) - grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_min_width) + grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_min_width) + grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_min_width) + grid_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_min_width) submit_layout = QGridLayout() - submit_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + submit_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) submit_layout.setSpacing(SXLookFeelConst.grid_spacing) submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span, token_widget_min_width) - submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_min_width) - submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_min_width) - submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_min_width) + submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_min_width) + submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_min_width) + submit_layout.setColumnMinimumWidth(grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_min_width) title_hbox.addLayout(title_layout) -# title_hbox.addStretch(1) - title_layout.setColumnStretch(grid_row_origin + token_label_col_span, title_layout.columnStretch(grid_row_origin+token_label_col_span) + 1) + # title_hbox.addStretch(1) + title_layout.setColumnStretch(grid_row_origin + token_label_col_span, + title_layout.columnStretch(grid_row_origin + token_label_col_span) + 1) scroll_layout.addLayout(title_hbox) scroll_layout.addLayout(grid_layout) scroll_layout.addLayout(submit_layout) @@ -1987,8 +2190,8 @@ def __init__(self, name, helical, parent=None): temp_label = QLabel("%s" % (self.sxcmdwidget.sxcmd.get_mode_name_for("human"))) temp_label.setMinimumWidth(title_label_min_width) temp_label.setMinimumHeight(title_label_min_height) -# temp_label.setFixedWidth(title_label_min_width) -# temp_label.setFixedHeight(title_label_min_height) + # temp_label.setFixedWidth(title_label_min_width) + # temp_label.setFixedHeight(title_label_min_height) title_layout.addWidget(temp_label, grid_row, grid_col_origin, title_row_span, title_col_span) # @@ -2000,8 +2203,9 @@ def __init__(self, name, helical, parent=None): temp_label.setWordWrap(True) temp_label.setMinimumWidth(short_info_min_width) temp_label.setMinimumHeight(short_info_min_height) -# temp_label.setFixedHeight(short_info_min_height) - title_layout.addWidget(temp_label, grid_row, grid_col_origin + title_col_span, short_info_row_span, short_info_col_span) + # temp_label.setFixedHeight(short_info_min_height) + title_layout.addWidget(temp_label, grid_row, grid_col_origin + title_col_span, short_info_row_span, + short_info_col_span) grid_row += short_info_row_span @@ -2010,16 +2214,17 @@ def __init__(self, name, helical, parent=None): temp_label = QLabel("%s" % (self.sxcmdwidget.sxcmd.get_mode_name_for("human"))) temp_label.setMinimumWidth(title_label_min_width) temp_label.setMinimumHeight(title_label_min_height) -# temp_label.setFixedWidth(title_label_min_width) -# temp_label.setFixedHeight(title_label_min_height) + # temp_label.setFixedWidth(title_label_min_width) + # temp_label.setFixedHeight(title_label_min_height) title_layout.addWidget(temp_label, grid_row, grid_col_origin, title_row_span, title_col_span) temp_label = QLabel("Set advanced parameters", self) temp_label.setWordWrap(True) temp_label.setMinimumWidth(short_info_min_width) temp_label.setMinimumHeight(short_info_min_height) -# temp_label.setFixedHeight(short_info_min_height) - title_layout.addWidget(temp_label, grid_row, grid_col_origin + title_col_span, short_info_row_span, short_info_col_span) + # temp_label.setFixedHeight(short_info_min_height) + title_layout.addWidget(temp_label, grid_row, grid_col_origin + title_col_span, short_info_row_span, + short_info_col_span) # Add space grid_row += 2 @@ -2041,7 +2246,7 @@ def __init__(self, name, helical, parent=None): if curr_group == tab_group: # First, handle very special cases if cmd_token.type == "user_func": - n_widgets = 2 # function type has two line edit boxes + n_widgets = 2 # function type has two line edit boxes cmd_token_restore_widget = [None] * n_widgets cmd_token_widget = [None] * n_widgets cmd_token_subwidget_left = None @@ -2055,17 +2260,22 @@ def __init__(self, name, helical, parent=None): widget_index = 0 temp_label = QLabel(cmd_token.label[widget_index]) temp_label.setMinimumWidth(token_label_min_width) - grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, token_label_col_span) + grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, + token_label_col_span) - assert(cmd_token.is_required == False) + assert (cmd_token.is_required == False) restores = cmd_token.restore[widget_index][helical] if len(restores) == 1: cmd_token_restore_widget[widget_index] = QPushButton("%s" % restores[0]) cmd_token_restore_widget[widget_index].setStyleSheet(custom_style) - cmd_token_restore_widget[widget_index].setToolTip(''+default_cmd_token_restore_tooltip+'') - grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) - - cmd_token_restore_widget[widget_index].clicked.connect(partial(self.handle_restore_widget_event, cmd_token, widget_index)) + cmd_token_restore_widget[widget_index].setToolTip( + '' + default_cmd_token_restore_tooltip + '') + grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, + grid_col_origin + token_label_col_span, token_widget_row_span, + token_widget_col_span) + + cmd_token_restore_widget[widget_index].clicked.connect( + partial(self.handle_restore_widget_event, cmd_token, widget_index)) else: cmd_token_restore_widget[widget_index] = QComboBox() cmd_token_restore_widget[widget_index].addItems(restores) @@ -2073,55 +2283,75 @@ def __init__(self, name, helical, parent=None): cmd_token_restore_widget[widget_index].lineEdit().setReadOnly(True) cmd_token_restore_widget[widget_index].lineEdit().setAlignment(QtCore.Qt.AlignCenter) cmd_token_restore_widget[widget_index].setStyleSheet(custom_style) - cmd_token_restore_widget[widget_index].setToolTip(''+default_cmd_token_restore_tooltip+'') - grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) - cmd_token_restore_widget[widget_index].activated.connect(partial(self.handle_restore_widget_event, cmd_token, widget_index)) + cmd_token_restore_widget[widget_index].setToolTip( + '' + default_cmd_token_restore_tooltip + '') + grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, + grid_col_origin + token_label_col_span, token_widget_row_span, + token_widget_col_span) + cmd_token_restore_widget[widget_index].activated.connect( + partial(self.handle_restore_widget_event, cmd_token, widget_index)) # cmd_token_widget[widget_index] = SXLineEdit(self) cmd_token_widget[widget_index] = SXLineEdit(cmd_token.key_base) cmd_token_widget[widget_index].setText(cmd_token.restore[widget_index][helical][0]) - cmd_token_widget[widget_index].setToolTip(''+cmd_token.help[widget_index]+'') - grid_layout.addWidget(cmd_token_widget[widget_index], grid_row, grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_row_span, token_widget_col_span) + cmd_token_widget[widget_index].setToolTip('' + cmd_token.help[widget_index] + '') + grid_layout.addWidget(cmd_token_widget[widget_index], grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_row_span, token_widget_col_span) - grid_row += 1 + grid_row += 1 # Create widgets for external file path containing above user function widget_index = 1 temp_label = QLabel(cmd_token.label[widget_index]) - grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, token_label_col_span) + grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, + token_label_col_span) - assert(cmd_token.is_required == False) - cmd_token_restore_widget[widget_index] = QPushButton("%s" % cmd_token.restore[widget_index][helical][0]) + assert (cmd_token.is_required == False) + cmd_token_restore_widget[widget_index] = QPushButton( + "%s" % cmd_token.restore[widget_index][helical][0]) cmd_token_restore_widget[widget_index].setStyleSheet(custom_style) - cmd_token_restore_widget[widget_index].setToolTip(''+default_cmd_token_restore_tooltip+'') - grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + cmd_token_restore_widget[widget_index].setToolTip( + '' + default_cmd_token_restore_tooltip + '') + grid_layout.addWidget(cmd_token_restore_widget[widget_index], grid_row, + grid_col_origin + token_label_col_span, token_widget_row_span, + token_widget_col_span) cmd_token_widget[widget_index] = SXLineEdit(cmd_token.key_base) - cmd_token_widget[widget_index].setText(cmd_token.restore[widget_index][helical][0]) # Because default user functions is internal - cmd_token_widget[widget_index].setToolTip(''+cmd_token.help[widget_index]+'') - grid_layout.addWidget(cmd_token_widget[widget_index], grid_row, grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_row_span, token_widget_col_span) + cmd_token_widget[widget_index].setText( + cmd_token.restore[widget_index][helical][0]) # Because default user functions is internal + cmd_token_widget[widget_index].setToolTip('' + cmd_token.help[widget_index] + '') + grid_layout.addWidget(cmd_token_widget[widget_index], grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_row_span, token_widget_col_span) - cmd_token_restore_widget[widget_index].clicked.connect(partial(self.handle_restore_widget_event, cmd_token, widget_index)) + cmd_token_restore_widget[widget_index].clicked.connect( + partial(self.handle_restore_widget_event, cmd_token, widget_index)) file_format = "py" temp_btn = QPushButton("Select Python script") - temp_btn.setToolTip(''+"Display open file dialog to select .%s python script file" % file_format) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget[widget_index], file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select .%s python script file" % file_format) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget[widget_index], file_format)) - grid_row += 1 + grid_row += 1 -# temp_label = QLabel(cmd_token.help[widget_index]) -# grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, token_label_col_span) -# -# grid_row += 1 + # temp_label = QLabel(cmd_token.help[widget_index]) + # grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, token_label_col_span) + # + # grid_row += 1 # Then, handle the other cases else: # Create label widget temp_label = QLabel(cmd_token.label) temp_label.setMinimumWidth(token_label_min_width) - grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, token_label_col_span) + grid_layout.addWidget(temp_label, grid_row, grid_col_origin, token_label_row_span, + token_label_col_span) # Create widget and associate it to this cmd_token cmd_token_restore_widget = None @@ -2153,7 +2383,7 @@ def __init__(self, name, helical, parent=None): custom_style = "QPushButton {color:red; }" is_btn_enable = False cmd_token_restore_tooltip = required_cmd_token_restore_tooltip - + cmd_token_restore_widget = QPushButton("%s" % btn_name) cmd_token_restore_widget.setStyleSheet(custom_style) cmd_token_restore_widget.setEnabled(is_btn_enable) @@ -2163,8 +2393,9 @@ def __init__(self, name, helical, parent=None): grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span - ) - cmd_token_restore_widget.clicked.connect(partial(self.handle_restore_widget_event, cmd_token)) + ) + cmd_token_restore_widget.clicked.connect( + partial(self.handle_restore_widget_event, cmd_token)) else: custom_style = "QComboBox {color:gray; }" is_btn_enable = True @@ -2196,8 +2427,9 @@ def __init__(self, name, helical, parent=None): grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span - ) - cmd_token_restore_widget.activated.connect(partial(self.handle_restore_widget_event, cmd_token)) + ) + cmd_token_restore_widget.activated.connect( + partial(self.handle_restore_widget_event, cmd_token)) # construct new widget(s) for this command token cmd_token_widget = SXCheckBox(cmd_token.key_base) @@ -2206,7 +2438,9 @@ def __init__(self, name, helical, parent=None): else: cmd_token_widget.setCheckState(Qt.Unchecked) cmd_token_widget.setEnabled(not cmd_token.is_locked) - grid_layout.addWidget(cmd_token_widget, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(cmd_token_widget, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_row_span, token_widget_col_span) else: @@ -2238,8 +2472,9 @@ def __init__(self, name, helical, parent=None): grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span - ) - cmd_token_restore_widget.clicked.connect(partial(self.handle_restore_widget_event, cmd_token)) + ) + cmd_token_restore_widget.clicked.connect( + partial(self.handle_restore_widget_event, cmd_token)) else: custom_style = "QComboBox {color:gray; }" is_btn_enable = True @@ -2271,439 +2506,706 @@ def __init__(self, name, helical, parent=None): grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span - ) - cmd_token_restore_widget.activated.connect(partial(self.handle_restore_widget_event, cmd_token)) + ) + cmd_token_restore_widget.activated.connect( + partial(self.handle_restore_widget_event, cmd_token)) cmd_token_widget = SXLineEdit(cmd_token.key_base) cmd_token_widget.setText(str(restores[0])) cmd_token_widget.setEnabled(not cmd_token.is_locked) - grid_layout.addWidget(cmd_token_widget, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_row_span, token_widget_col_span) - + grid_layout.addWidget(cmd_token_widget, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_row_span, token_widget_col_span) if cmd_token.type == "displayable_list": file_format = cmd_token.type temp_btn = QPushButton("Select any displayables") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select displayable data files of any supported formats") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select displayable data files of any supported formats") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "data2d3d_both": file_format = cmd_token.type temp_btn = QPushButton("Select any image/volume") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select an image/volume file of any supported format") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select an image/volume file of any supported format") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "mic_both": file_format = "mrc2d_mic_both" temp_btn = QPushButton("Select MRC mic/movie") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a MRC format micrograph or movie file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a MRC format micrograph or movie file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any mic/movie") - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph or movie file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph or movie file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "mic_one": file_format = "mrc2d_mic_one" temp_btn = QPushButton("Select MRC micrograph") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a MRC format micrograph file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a MRC format micrograph file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any micrograph") - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "mic_one_list": file_format = "mrc2d_mic_one_list" temp_btn = QPushButton("Select MRC micrographs") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select MRC format micrograph files") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select MRC format micrograph files") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any micrographs") - temp_btn.setToolTip(''+"Display open file dialog to select micrograph files of any supported formats") + temp_btn.setToolTip( + '' + "Display open file dialog to select micrograph files of any supported formats") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "mic_stack": file_format = "mrc2d_mic_stack" temp_btn = QPushButton("Select MRC movie") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a MRC format movie file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a MRC format movie file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any movie") - temp_btn.setToolTip(''+"Display open file dialog to select a movie file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a movie file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "data2d_one": file_format = "hdf2d_one" temp_btn = QPushButton("Select HDF image") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a HDF format image file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a HDF format image file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any image") - temp_btn.setToolTip(''+"Display open file dialog to select a image file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a image file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "bdb2d_stack" or cmd_token.type == "output_bdb2d_stack": file_format = "bdb2d_stack" temp_btn = QPushButton("Select BDB image stack") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a BDB format image stack file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a BDB format image stack file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "data2d_stack": - file_format = "bdb2d_stack" - temp_btn = QPushButton("Select BDB image stack") + file_format = cmd_token.type + temp_btn = QPushButton("Select Star image stack") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a BDB format image stack file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a BDB format image stack file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any image stack") - temp_btn.setToolTip(''+"Display open file dialog to select a image stack file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a image stack file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "data3d_one": file_format = "hdf3d_one" temp_btn = QPushButton("Select HDF volume") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a HDF format volume file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a HDF format volume file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any volume") - temp_btn.setToolTip(''+"Display open file dialog to select a volume file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a volume file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "data3d_stack": file_format = "hdf3d_stack" temp_btn = QPushButton("Select HDF volume stack") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a HDF format volume stack file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a HDF format volume stack file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any volume stack") - temp_btn.setToolTip(''+"Display open file dialog to select a volume stack file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a volume stack file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "select_mic_both": file_format = cmd_token.type temp_btn = QPushButton("Select mic/movie list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph/movie selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph/movie selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "select_mic_one": file_format = cmd_token.type temp_btn = QPushButton("Select micrograph list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "select_mic_one_ext": file_format = "select_mic_one" temp_btn = QPushButton("Select micrograph list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "mic_one" temp_btn = QPushButton("Select any micrograph") - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "select_mic_stack": file_format = cmd_token.type temp_btn = QPushButton("Select movie list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a micrograph movie selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a micrograph movie selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "select_data2d_stack": file_format = cmd_token.type temp_btn = QPushButton("Select image list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a image selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a image selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "select_drift_params": file_format = cmd_token.type temp_btn = QPushButton("Select drift params list") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a drift shift parameters selection file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a drift shift parameters selection file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_any_txt": file_format = cmd_token.type temp_btn = QPushButton("Select parameters text") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a parameters text file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a parameters text file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_proj_txt": file_format = cmd_token.type temp_btn = QPushButton("Select projection params") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a projection parameters file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a projection parameters file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_coords_any": file_format = "params_coords_box" temp_btn = QPushButton("Select BOX coordinates") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a EMAN BOX coordinates file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a EMAN BOX coordinates file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = cmd_token.type temp_btn = QPushButton("Select any coordinates") - temp_btn.setToolTip(''+"Display open file dialog to select a coordinates file of any supported format") + temp_btn.setToolTip( + '' + "Display open file dialog to select a coordinates file of any supported format") temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) elif cmd_token.type == "params_cter_txt": file_format = cmd_token.type temp_btn = QPushButton("Select CTER partres") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a CTER partres parameters file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a CTER partres parameters file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_rebox_rbx": file_format = cmd_token.type temp_btn = QPushButton("Select SPHIRE rebox") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a SPHIRE rebox file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a SPHIRE rebox file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_drift_txt": file_format = cmd_token.type temp_btn = QPushButton("Select drift shift params") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a drift shift parameters file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a drift shift parameters file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "rot_matrix": file_format = cmd_token.type temp_btn = QPushButton("Select matrix file") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a rotational matrix file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a rotational matrix file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_relion_star": file_format = cmd_token.type temp_btn = QPushButton("Select RELION STAR file") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a RELION STAR file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a RELION STAR file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + file_format = "INVISIBLE" + temp_btn = QPushButton("%s" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) + temp_btn.setEnabled(False) + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setMinimumWidth(func_btn_min_width) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + elif cmd_token.type == "params_star": + file_format = cmd_token.type + temp_btn = QPushButton("Select STAR file") + temp_btn.setMinimumWidth(func_btn_min_width) + temp_btn.setToolTip('' + "Display open file dialog to select a STAR file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, + cmd_token_widget, file_format)) + file_format = "INVISIBLE" + temp_btn = QPushButton("%s" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) + temp_btn.setEnabled(False) + temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0);' + ' border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setMinimumWidth(func_btn_min_width) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + elif cmd_token.type == "submission_temp": + file_format = cmd_token.type + file_format = "sh" + temp_btn = QPushButton("Select template") + temp_btn.setMinimumWidth(func_btn_min_width) + temp_btn.setToolTip( + '' + "Display open file dialog to select a parameters text file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_any_json": file_format = cmd_token.type temp_btn = QPushButton("Select JSON file") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dailog to select a JSON file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip('' + "Display open file dailog to select a JSON file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_any_h5": file_format = cmd_token.type temp_btn = QPushButton("Select h5 file") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dailog to select a h5 file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip('' + "Display open file dailog to select a h5 file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "spectrum1d": file_format = cmd_token.type temp_btn = QPushButton("Select power spectrum") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a 1D power spectrum file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select a 1D power spectrum file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "mtf": file_format = cmd_token.type temp_btn = QPushButton("Select MTF data") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a MTF data file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip('' + "Display open file dialog to select a MTF data file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "pdb": file_format = cmd_token.type temp_btn = QPushButton("Select PDB data") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select a PDB data file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip('' + "Display open file dialog to select a PDB data file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "exe": file_format = cmd_token.type temp_btn = QPushButton("Select executable") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display open file dialog to select an executable file") - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) - temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + temp_btn.setToolTip( + '' + "Display open file dialog to select an executable file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "py": file_format = cmd_token.type temp_btn = QPushButton("Select python file") @@ -2729,186 +3231,203 @@ def __init__(self, name, helical, parent=None): elif cmd_token.type == "dir" or cmd_token.type == "dir_list" or cmd_token.type == "output_continue": temp_btn = QPushButton("Select directory") temp_btn.setMinimumWidth(func_btn_min_width) - temp_btn.setToolTip(''+"Display select directory dialog"+'') - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + temp_btn.setToolTip('' + "Display select directory dialog" + '') + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) temp_btn.clicked.connect(partial(self.sxcmdwidget.select_dir, cmd_token_widget)) file_format = "INVISIBLE" temp_btn = QPushButton("%s" % file_format) - temp_btn.setToolTip(''+"This is %s button" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) temp_btn.setEnabled(False) - temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "abs_freq": # Create button for resolution display. Here, I use button to keep the look & feel. cmd_token_subwidget_left = QPushButton("Label for Resolution [A]") cmd_token_subwidget_left.setEnabled(False) cmd_token_subwidget_left.setMinimumWidth(func_btn_min_width) - cmd_token_subwidget_left.setToolTip(''+"Resolution [A] corresponding to absolute frequency [1/Pixel]"+'') - grid_layout.addWidget(cmd_token_subwidget_left, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + cmd_token_subwidget_left.setToolTip( + '' + "Resolution [A] corresponding to absolute frequency [1/Pixel]" + '') + grid_layout.addWidget(cmd_token_subwidget_left, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) # Create button to show the associated calculator dialog. cmd_token_subwidget_right = QPushButton("Use resolution [A]") - cmd_token_subwidget_right.setToolTip(''+"Display calculator dialog to use the resolution [A] instead of absolute frequency [1/Pixel]. It calculates absolute frequency [1/Pixel] (abs_freq) From resolution [A] (ares) using a give pixel size [A/Pixel] (apix), where abs_freq = apix/ares. ") + cmd_token_subwidget_right.setToolTip( + '' + "Display calculator dialog to use the resolution [A] instead of absolute frequency [1/Pixel]. It calculates absolute frequency [1/Pixel] (abs_freq) From resolution [A] (ares) using a give pixel size [A/Pixel] (apix), where abs_freq = apix/ares. ") cmd_token_subwidget_right.setMinimumWidth(func_btn_min_width) - grid_layout.addWidget(cmd_token_subwidget_right, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + grid_layout.addWidget(cmd_token_subwidget_right, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) # Associated this subwidget to open the calculator dialog const_register_widget_apix = self.sxcmdwidget.sxconst_set.dict["apix"].register_widget - cmd_token_calculator_dialog = SXDialogCalculator(const_register_widget_apix, cmd_token_widget, cmd_token_subwidget_left, self) + cmd_token_calculator_dialog = SXDialogCalculator(const_register_widget_apix, + cmd_token_widget, cmd_token_subwidget_left, + self) cmd_token_calculator_dialog.reflect_external_local_update_abs_freq() # Connect the main widget "editing finished" event to the calculator dialog - cmd_token_widget.editingFinished.connect(cmd_token_calculator_dialog.reflect_external_local_update_abs_freq) + cmd_token_widget.editingFinished.connect( + cmd_token_calculator_dialog.reflect_external_local_update_abs_freq) # Connect the right subwidget "clicked" event to the calculator dialog cmd_token_subwidget_right.clicked.connect(cmd_token_calculator_dialog.show) -### elif cmd_token.type == "any_micrograph": -### temp_btn = QPushButton("Select Image") -### temp_btn.setToolTip(''+"Display open file dialog to select standard format image file (e.g. .hdf, .mrc)") -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) -### file_format = "txt" -### temp_btn = QPushButton("Select text file") -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select a parameters text file" ) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### elif cmd_token.type == "any_image": -### temp_btn = QPushButton("Select Image") -### temp_btn.setToolTip(''+"Display open file dialog to select standard format image file (e.g. .hdf, .mrc)") -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "any_image_list": -### temp_btn = QPushButton("Select Images") -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select standard format image files (e.g. .hdf, .mrc)") -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, cmd_token.type)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "any_file": -### temp_btn = QPushButton("Select File") -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select file (e.g. *.*)") -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "any_file_list": -### temp_btn = QPushButton("Select Files") -### temp_btn.setToolTip(''+"Display open file dialog to select files (e.g. *.*)") -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, cmd_token.type)) -### file_format = "bdb" -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### elif cmd_token.type == "image": -### file_format = "hdf" -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### file_format = "bdb" -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### elif cmd_token.type == "bdb": -### file_format = "bdb" -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "hdf": -### file_format = cmd_token.type -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "mrc": -### file_format = cmd_token.type -### temp_btn = QPushButton("Select .%s" % file_format) -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) -### elif cmd_token.type == "txt": -### file_format = cmd_token.type -### temp_btn = QPushButton("Select text file") -### temp_btn.setMinimumWidth(func_btn_min_width) -### temp_btn.setToolTip(''+"Display open file dialog to select a parameters text file") -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) -### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) -### file_format = "INVISIBLE" -### temp_btn = QPushButton("%s" % file_format) -### temp_btn.setToolTip(''+"This is %s button" % file_format) -### temp_btn.setEnabled(False) -### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') -### temp_btn.setMinimumWidth(func_btn_min_width) -### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "any_micrograph": + ### temp_btn = QPushButton("Select Image") + ### temp_btn.setToolTip(''+"Display open file dialog to select standard format image file (e.g. .hdf, .mrc)") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) + ### file_format = "txt" + ### temp_btn = QPushButton("Select text file") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select a parameters text file" ) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### elif cmd_token.type == "any_image": + ### temp_btn = QPushButton("Select Image") + ### temp_btn.setToolTip(''+"Display open file dialog to select standard format image file (e.g. .hdf, .mrc)") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "any_image_list": + ### temp_btn = QPushButton("Select Images") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select standard format image files (e.g. .hdf, .mrc)") + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, cmd_token.type)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "any_file": + ### temp_btn = QPushButton("Select File") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select file (e.g. *.*)") + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "any_file_list": + ### temp_btn = QPushButton("Select Files") + ### temp_btn.setToolTip(''+"Display open file dialog to select files (e.g. *.*)") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, cmd_token.type)) + ### file_format = "bdb" + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### elif cmd_token.type == "image": + ### file_format = "hdf" + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### file_format = "bdb" + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### elif cmd_token.type == "bdb": + ### file_format = "bdb" + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "hdf": + ### file_format = cmd_token.type + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "mrc": + ### file_format = cmd_token.type + ### temp_btn = QPushButton("Select .%s" % file_format) + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select .%s format image file" % file_format) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + ### elif cmd_token.type == "txt": + ### file_format = cmd_token.type + ### temp_btn = QPushButton("Select text file") + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### temp_btn.setToolTip(''+"Display open file dialog to select a parameters text file") + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) + ### self.connect(temp_btn, SIGNAL("clicked()"), partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + ### file_format = "INVISIBLE" + ### temp_btn = QPushButton("%s" % file_format) + ### temp_btn.setToolTip(''+"This is %s button" % file_format) + ### temp_btn.setEnabled(False) + ### temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + ### temp_btn.setMinimumWidth(func_btn_min_width) + ### grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) else: - if cmd_token.type not in ["int", "float", "string", "output", "apix", "ctfwin", "box", "radius", "sym", "mass", "filament_width"]: ERROR("Logical Error: Encountered unsupported type (%s). Consult with the developer." % cmd_token.type, "%s in %s" % (__name__, os.path.basename(__file__))) - - # if cmd_token.type in ["output", "output_continue", "output_bdb2d_stack"]: - # # Need to add output info button in future + if cmd_token.type not in ["int", "float", "string", "output", "apix", "ctfwin", "box", + "radius", "sym", "mass", "filament_width"]: ERROR( + "Logical Error: Encountered unsupported type (%s). Consult with the developer." % cmd_token.type, + "%s in %s" % (__name__, os.path.basename(__file__))) - cmd_token_widget.setToolTip(''+cmd_token.help+'') - cmd_token_restore_widget.setToolTip(''+cmd_token_restore_tooltip+'') + # if cmd_token.type in ["output", "output_continue", "output_bdb2d_stack"]: + # # Need to add output info button in future + + cmd_token_widget.setToolTip('' + cmd_token.help + '') + cmd_token_restore_widget.setToolTip('' + cmd_token_restore_tooltip + '') grid_row += 1 - + # Register this widget cmd_token.restore_widget = cmd_token_restore_widget cmd_token.widget = cmd_token_widget cmd_token.subwidget_left = cmd_token_subwidget_left cmd_token.subwidget_right = cmd_token_subwidget_right cmd_token.calculator_dialog = cmd_token_calculator_dialog - + is_necessary_to_connet_now = True if len(cmd_token_abs_freq_list) == 0: is_necessary_to_connet_now = False @@ -2922,7 +3441,7 @@ def __init__(self, name, helical, parent=None): if is_necessary_to_connet_now and cmd_token_apix.widget is None: is_necessary_to_connet_now = False # else: # Do nothing - + if is_necessary_to_connet_now: # Associated the widget of apix command token to the calculator dialog each other assert (cmd_token_apix.type == "apix") @@ -2943,7 +3462,8 @@ def __init__(self, name, helical, parent=None): # Exclude itself if cmd_token_abs_freq.key_base != other_cmd_token_abs_freq.key_base: cmd_token_abs_freq.other_dialog_list.append(other_cmd_token_abs_freq.calculator_dialog) - cmd_token_abs_freq.calculator_dialog.sxcmd_token_other_dialog_list_abs_freq.append(other_cmd_token_abs_freq.calculator_dialog) + cmd_token_abs_freq.calculator_dialog.sxcmd_token_other_dialog_list_abs_freq.append( + other_cmd_token_abs_freq.calculator_dialog) # Register pixel size token widget to this absolut frequency calculator dialog # if cmd_token_abs_freq is None: # print("MRK_DEBUG: cmd_token_abs_freq is None") @@ -2954,14 +3474,15 @@ def __init__(self, name, helical, parent=None): cmd_token_abs_freq.calculator_dialog.sxcmd_token_widget_apix = cmd_token_apix.widget # Register this absolut frequency calculator dialog to pixel size token cmd_token_apix.other_dialog_list.append(cmd_token_abs_freq.calculator_dialog) - + # print("MRK_DEBUG: len(cmd_token_apix.other_dialog_list) := \"{}\"".format(len(cmd_token_apix.other_dialog_list))) - + # Initialise pixel size of all calculate dialogs self.handle_apix_token_editing_finished_event(cmd_token_apix) # Connect the apix command token widget "editing finished" event to the calculator dialog - cmd_token_apix.widget.editingFinished.connect(partial(self.handle_apix_token_editing_finished_event, cmd_token_apix)) - + cmd_token_apix.widget.editingFinished.connect( + partial(self.handle_apix_token_editing_finished_event, cmd_token_apix)) + if tab_group == "main": # Add space grid_row += 1 @@ -2973,15 +3494,19 @@ def __init__(self, name, helical, parent=None): # self.mpi_nproc_edit = QLineEdit(self) self.mpi_nproc_edit = QLineEdit() - self.mpi_nproc_edit.setToolTip(''+"Number of processors to use. default is single processor mode"+'') - submit_layout.addWidget(self.mpi_nproc_edit, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + self.mpi_nproc_edit.setToolTip( + '' + "Number of processors to use. default is single processor mode" + '') + submit_layout.addWidget(self.mpi_nproc_edit, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) # Add save parameters button self.save_params_btn = QPushButton("Save parameters") self.save_params_btn.setMinimumWidth(btn_min_width) - self.save_params_btn.setToolTip(''+"Save gui parameter settings"+'') + self.save_params_btn.setToolTip('' + "Save gui parameter settings" + '') self.save_params_btn.clicked.connect(self.sxcmdwidget.save_params) - submit_layout.addWidget(self.save_params_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + submit_layout.addWidget(self.save_params_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span * 2) grid_row += 1 @@ -2995,15 +3520,20 @@ def __init__(self, name, helical, parent=None): else: mpi_command_line_template = "" self.mpi_cmd_line_edit.setText(mpi_command_line_template) - self.mpi_cmd_line_edit.setToolTip(''+"Template of MPI command line (e.g. \"mpirun -np XXX_SXMPI_NPROC_XXX --host n0,n1,n2 XXX_SXCMD_LINE_XXX\"). if empty, use \"mpirun -np XXX_SXMPI_NPROC_XXX XXX_SXCMD_LINE_XXX\"") - submit_layout.addWidget(self.mpi_cmd_line_edit, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + self.mpi_cmd_line_edit.setToolTip( + '' + "Template of MPI command line (e.g. \"mpirun -np XXX_SXMPI_NPROC_XXX --host n0,n1,n2 XXX_SXCMD_LINE_XXX\"). if empty, use \"mpirun -np XXX_SXMPI_NPROC_XXX XXX_SXCMD_LINE_XXX\"") + submit_layout.addWidget(self.mpi_cmd_line_edit, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) # Add load parameters button self.load_params_btn = QPushButton("Load parameters") self.load_params_btn.setMinimumWidth(btn_min_width) - self.load_params_btn.setToolTip(''+"Load gui parameter settings to retrieve a previously-saved one"+'') + self.load_params_btn.setToolTip( + '' + "Load gui parameter settings to retrieve a previously-saved one" + '') self.load_params_btn.clicked.connect(self.sxcmdwidget.load_params) - submit_layout.addWidget(self.load_params_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + submit_layout.addWidget(self.load_params_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span * 2) grid_row += 1 @@ -3028,17 +3558,19 @@ def __init__(self, name, helical, parent=None): self.qsub_enable_checkbox.setCheckState(Qt.Checked) elif not self.sxcmdwidget.sxcmd.is_submittable: self.qsub_enable_checkbox.setCheckState(Qt.Unchecked) - elif 'SPHIRE_ENABLE_QSUB' in os.environ: # assert(is_qsub_enabled == False) + elif 'SPHIRE_ENABLE_QSUB' in os.environ: # assert(is_qsub_enabled == False) if os.environ['SPHIRE_ENABLE_QSUB'].lower() == 'true': self.qsub_enable_checkbox.setCheckState(Qt.Checked) else: self.qsub_enable_checkbox.setCheckState(Qt.Unchecked) else: self.qsub_enable_checkbox.setCheckState(Qt.Unchecked) - self.qsub_enable_checkbox.setToolTip(''+"Submit job to queue"+'') - self.qsub_enable_checkbox.stateChanged.connect(self.set_qsub_enable_state) # To control enable state of the following qsub related widgets + self.qsub_enable_checkbox.setToolTip('' + "Submit job to queue" + '') + self.qsub_enable_checkbox.stateChanged.connect( + self.set_qsub_enable_state) # To control enable state of the following qsub related widgets self.qsub_enable_checkbox.setEnabled(self.sxcmdwidget.sxcmd.is_submittable) - submit_layout.addWidget(self.qsub_enable_checkbox, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + submit_layout.addWidget(self.qsub_enable_checkbox, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) grid_row += 1 @@ -3049,11 +3581,12 @@ def __init__(self, name, helical, parent=None): self.qsub_job_name_edit = QLineEdit() if self.sxcmdwidget.sxcmd.is_submittable == True: self.qsub_job_name_edit.setText(self.sxcmdwidget.sxcmd.get_mode_name_for("file_path")) - else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) - assert(self.sxcmdwidget.sxcmd.mpi_support == False) + else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) + assert (self.sxcmdwidget.sxcmd.mpi_support == False) self.qsub_job_name_edit.setText("N/A") - self.qsub_job_name_edit.setToolTip(''+"Name of this job"+'') - submit_layout.addWidget(self.qsub_job_name_edit, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + self.qsub_job_name_edit.setToolTip('' + "Name of this job" + '') + submit_layout.addWidget(self.qsub_job_name_edit, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) grid_row += 1 @@ -3068,25 +3601,32 @@ def __init__(self, name, helical, parent=None): else: submission_command = "qsub" self.qsub_cmd_edit.setText(submission_command) - else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) - assert(self.sxcmdwidget.sxcmd.mpi_support == False) + else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) + assert (self.sxcmdwidget.sxcmd.mpi_support == False) self.qsub_cmd_edit.setText("N/A") - self.qsub_cmd_edit.setToolTip(''+"Name of submission command to queue job"+'') - submit_layout.addWidget(self.qsub_cmd_edit, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + self.qsub_cmd_edit.setToolTip('' + "Name of submission command to queue job" + '') + submit_layout.addWidget(self.qsub_cmd_edit, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) self.cmd_line_btn = QPushButton("Generate command line") self.cmd_line_btn.setMinimumWidth(btn_min_width) - self.cmd_line_btn.setToolTip(''+"Generate command line from gui parameter settings and automatically save settings"+'') + self.cmd_line_btn.setToolTip( + '' + "Generate command line from gui parameter settings and automatically save settings" + '') self.cmd_line_btn.clicked.connect(self.sxcmdwidget.print_cmd_line) - submit_layout.addWidget(self.cmd_line_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + submit_layout.addWidget(self.cmd_line_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span * 2) grid_row += 1 self.pipe_line_btn = QPushButton("Add to pipeline folder") self.pipe_line_btn.setMinimumWidth(btn_min_width) - self.pipe_line_btn.setToolTip(''+"Generate executable files that and add them to the queue folder."+'') + self.pipe_line_btn.setToolTip( + '' + "Generate executable files that and add them to the queue folder." + '') self.pipe_line_btn.clicked.connect(self.sxcmdwidget.add_to_pipeline) - submit_layout.addWidget(self.pipe_line_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + submit_layout.addWidget(self.pipe_line_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span * 2) grid_row += 1 @@ -3101,17 +3641,23 @@ def __init__(self, name, helical, parent=None): else: submission_script_template = "msgui_qsub.sh" self.qsub_script_edit.setText(submission_script_template) - else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) - assert(self.sxcmdwidget.sxcmd.mpi_support == False) + else: # assert(self.sxcmdwidget.sxcmd.is_submittable == False) + assert (self.sxcmdwidget.sxcmd.mpi_support == False) self.qsub_script_edit.setText("N/A") - self.qsub_script_edit.setToolTip(''+"File name of submission script template (e.g. $PROJECT_DIR/msgui_qsub.sh)"+'') - submit_layout.addWidget(self.qsub_script_edit, grid_row, grid_col_origin + token_label_col_span, token_widget_row_span, token_widget_col_span) + self.qsub_script_edit.setToolTip( + '' + "File name of submission script template (e.g. $PROJECT_DIR/msgui_qsub.sh)" + '') + submit_layout.addWidget(self.qsub_script_edit, grid_row, grid_col_origin + token_label_col_span, + token_widget_row_span, token_widget_col_span) self.qsub_script_open_btn = QPushButton("Select template") self.qsub_script_open_btn.setMinimumWidth(func_btn_min_width) - self.qsub_script_open_btn.setToolTip(''+"Display open file dialog to select job submission script template file"+'') - self.qsub_script_open_btn.clicked.connect(partial(self.sxcmdwidget.select_file, self.qsub_script_edit, 'submission_template')) - submit_layout.addWidget(self.qsub_script_open_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span, token_widget_row_span, token_widget_col_span) + self.qsub_script_open_btn.setToolTip( + '' + "Display open file dialog to select job submission script template file" + '') + self.qsub_script_open_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, self.qsub_script_edit, 'submission_template')) + submit_layout.addWidget(self.qsub_script_open_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span, + token_widget_row_span, token_widget_col_span) # Add a run button # self.execute_btn = QPushButton("Run %s" % self.sxcmdwidget.sxcmd.get_mode_name_for("human")) @@ -3120,22 +3666,26 @@ def __init__(self, name, helical, parent=None): custom_style = "QPushButton {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #8D0)} QPushButton:pressed {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #084)} QPushButton:focus {font: bold; color: #000;border: 2px solid #8D0;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #8D0)} QPushButton:disabled {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #ff0000)}" self.execute_btn.setStyleSheet(custom_style) self.execute_btn.setMinimumWidth(btn_min_width) - self.execute_btn.setToolTip(''+"Run %s and automatically save gui parameter settings" % self.sxcmdwidget.sxcmd.get_mode_name_for("human")) + self.execute_btn.setToolTip( + '' + "Run %s and automatically save gui parameter settings" % self.sxcmdwidget.sxcmd.get_mode_name_for( + "human")) self.execute_btn.clicked.connect(self.sxcmdwidget.execute_cmd_line) - submit_layout.addWidget(self.execute_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + submit_layout.addWidget(self.execute_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span * 2) grid_row += 1 -### # Add a debug button -### sxoperand_set = self.construct_sxoperand_set() -### self.res_calculator = SXDialogCalculator(sxoperand_set, self) -### self.cmd_line_btn = QPushButton("Debug") -### self.cmd_line_btn.setMinimumWidth(btn_min_width) -### self.cmd_line_btn.setToolTip(''+"Button for debug"+'') -### self.connect(self.cmd_line_btn, SIGNAL("clicked()"), self.res_calculator.show) -### submit_layout.addWidget(self.cmd_line_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) -### -### grid_row += 1 + ### # Add a debug button + ### sxoperand_set = self.construct_sxoperand_set() + ### self.res_calculator = SXDialogCalculator(sxoperand_set, self) + ### self.cmd_line_btn = QPushButton("Debug") + ### self.cmd_line_btn.setMinimumWidth(btn_min_width) + ### self.cmd_line_btn.setToolTip(''+"Button for debug"+'') + ### self.connect(self.cmd_line_btn, SIGNAL("clicked()"), self.res_calculator.show) + ### submit_layout.addWidget(self.cmd_line_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span*2) + ### + ### grid_row += 1 # Initialize enable state of qsub related widgets self.set_qsub_enable_state() @@ -3169,9 +3719,9 @@ def set_qsub_enable_state(self): self.qsub_script_open_btn.setEnabled(is_enabled) def handle_restore_widget_event(self, sxcmd_token, widget_index=0, restore_idx=0): - assert(not sxcmd_token.is_locked) + assert (not sxcmd_token.is_locked) if sxcmd_token.type == "user_func": - assert(len(sxcmd_token.widget) == 2 and len(sxcmd_token.restore) == 2 and widget_index < 2) + assert (len(sxcmd_token.widget) == 2 and len(sxcmd_token.restore) == 2 and widget_index < 2) try: text = str(self.sender().text()) except AttributeError: @@ -3199,7 +3749,7 @@ def handle_restore_widget_event(self, sxcmd_token, widget_index=0, restore_idx=0 self.sender().blockSignals(False) if text == 'YES': sxcmd_token.widget.setChecked(Qt.Checked) - else: # sxcmd_token.restore == False + else: # sxcmd_token.restore == False sxcmd_token.widget.setChecked(Qt.Unchecked) else: try: @@ -3222,7 +3772,6 @@ def handle_restore_widget_event(self, sxcmd_token, widget_index=0, restore_idx=0 for sxcmd_token_other_dialog in sxcmd_token.other_dialog_list: sxcmd_token_other_dialog.reflect_external_local_update_apix() - def handle_apix_token_editing_finished_event(self, sxcmd_token_apix): assert (sxcmd_token_apix.type == "apix") # print("MRK_DEBUG: ") @@ -3233,6 +3782,7 @@ def handle_apix_token_editing_finished_event(self, sxcmd_token_apix): if cmd_token_calculator_dialog_abs_freq is not None: cmd_token_calculator_dialog_abs_freq.reflect_external_local_update_apix() + ### def handle_abs_freq_editing_finished_event(self, sxcmd_token_widget_abs_freq, sxcmd_token_subwidget_left_ares): ### apix_str = self.sxcmdwidget.sxconst_set.dict["apix"].register ### abs_freq_str = sxcmd_token_widget_abs_freq.text() @@ -3250,7 +3800,7 @@ def handle_apix_token_editing_finished_event(self, sxcmd_token_apix): # ======================================================================================== # Command Category Widget (opened by class SXMainWindow) class SXCmdCategoryWidget(QWidget): - def __init__(self, sxconst_set, sxcmd_category, helical=False, parent = None): + def __init__(self, sxconst_set, sxcmd_category, helical=False, parent=None): super(SXCmdCategoryWidget, self).__init__(parent) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -3273,10 +3823,10 @@ def __init__(self, sxconst_set, sxcmd_category, helical=False, parent = None): self.grid_col_origin = 0 # Layout variables - self.grid_layout = None # grid layout + self.grid_layout = None # grid layout - self.grid_row = self.grid_row_origin # Keep current row - self.grid_col = self.grid_col_origin # keep current column + self.grid_row = self.grid_row_origin # Keep current row + self.grid_col = self.grid_col_origin # keep current column self.sxcmd_btn_group = None # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -3291,13 +3841,13 @@ def __init__(self, sxconst_set, sxcmd_category, helical=False, parent = None): # -------------------------------------------------------------------------------- self.add_sxcmd_widgets(helical) -# # -------------------------------------------------------------------------------- -# # Load the previously saved parameter setting of this sx command -# # Override the registration of project constant parameter settings with the previously-saved one -# # -------------------------------------------------------------------------------- -# for sxcmd in self.sxcmd_category.cmd_list: -# if os.path.exists(sxcmd.widget.gui_settings_file_path): -# sxcmd.widget.read_params(sxcmd.widget.gui_settings_file_path) + # # -------------------------------------------------------------------------------- + # # Load the previously saved parameter setting of this sx command + # # Override the registration of project constant parameter settings with the previously-saved one + # # -------------------------------------------------------------------------------- + # for sxcmd in self.sxcmd_category.cmd_list: + # if os.path.exists(sxcmd.widget.gui_settings_file_path): + # sxcmd.widget.read_params(sxcmd.widget.gui_settings_file_path) # -------------------------------------------------------------------------------- # Alway select the 1st entry of the command list upon startup @@ -3313,12 +3863,14 @@ def setup_layout(self, background_brush): # Setup grid layout in the scroll area self.grid_layout = QGridLayout() - self.grid_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + self.grid_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) self.grid_layout.setSpacing(SXLookFeelConst.grid_spacing) self.grid_layout.setColumnMinimumWidth(0, SXLookFeelConst.sxcmd_btn_area_min_width) - # self.grid_layout.setColumnMinimumWidth(1, SXLookFeelConst.sxcmd_widget_area_min_width) - # Give the column of the command settings area a higher stretch priority so that the other area does not stretch horizontally - # self.grid_layout.setColumnStretch(self.grid_col_origin + self.sxcmd_btn_area_col_span, self.grid_layout.columnStretch(self.grid_col_origin + self.sxcmd_btn_area_col_span) + 1) + + # self.grid_layout.setColumnMinimumWidth(1, SXLookFeelConst.sxcmd_widget_area_min_width) + # Give the column of the command settings area a higher stretch priority so that the other area does not stretch horizontally + # self.grid_layout.setColumnStretch(self.grid_col_origin + self.sxcmd_btn_area_col_span, self.grid_layout.columnStretch(self.grid_col_origin + self.sxcmd_btn_area_col_span) + 1) # Add Pipeline SX Commands (sx*.py) associated widgets def add_sxcmd_widgets(self, helical): @@ -3349,12 +3901,14 @@ def add_sxcmd_widgets(self, helical): else: label_text = "UNKNOWN" - if current_role != None: + if current_role != None: self.grid_row += 1 # title=QLabel("%s (shift-click for wiki)" % label_text) - title=QLabel("%s (shift-click for wiki)" % label_text) - self.grid_layout.addWidget(title, self.grid_row, self.grid_col_origin, self.sxcmd_btn_row_span, self.sxcmd_btn_col_span) + title = QLabel( + "%s (shift-click for wiki)" % label_text) + self.grid_layout.addWidget(title, self.grid_row, self.grid_col_origin, self.sxcmd_btn_row_span, + self.sxcmd_btn_col_span) self.grid_row += 1 @@ -3363,9 +3917,10 @@ def add_sxcmd_widgets(self, helical): # Add buttons for this sx*.py processe sxcmd.btn = QPushButton(sxcmd.label) # sxcmd.btn.setCheckable(True) # NOTE: 2016/02/18 Toshio Moriya: With this setting, we can not move the focus to the unchecked butttons... PyQt bug? - sxcmd.btn.setToolTip(''+sxcmd.short_info+'') + sxcmd.btn.setToolTip('' + sxcmd.short_info + '') self.sxcmd_btn_group.addButton(sxcmd.btn) - self.grid_layout.addWidget(sxcmd.btn, self.grid_row, self.grid_col_origin, self.sxcmd_btn_row_span, self.sxcmd_btn_col_span) + self.grid_layout.addWidget(sxcmd.btn, self.grid_row, self.grid_col_origin, self.sxcmd_btn_row_span, + self.sxcmd_btn_col_span) # Create SXCmdWidget for this sx*.py processe sxcmd.widget = SXCmdWidget(self.sxconst_set, sxcmd, helical, self) @@ -3395,14 +3950,14 @@ def handle_sxcmd_btn_event(self, sxcmd): if self.cur_sxcmd == sxcmd: return if self.cur_sxcmd != None: - custom_style = "QPushButton {font: normal; color:black; }" # custom_style = "QPushButton {color:#000; }" + custom_style = "QPushButton {font: normal; color:black; }" # custom_style = "QPushButton {color:#000; }" self.cur_sxcmd.btn.setStyleSheet(custom_style) self.cur_sxcmd = sxcmd if self.cur_sxcmd != None: self.stacked_layout.setCurrentWidget(self.cur_sxcmd.widget) - custom_style = "QPushButton {font: bold; color:blue; }" # custom_style = "QPushButton {font: bold; color:#8D0; }" + custom_style = "QPushButton {font: bold; color:blue; }" # custom_style = "QPushButton {font: bold; color:#8D0; }" self.cur_sxcmd.btn.setStyleSheet(custom_style) def quit_all_child_applications(self): @@ -3410,6 +3965,7 @@ def quit_all_child_applications(self): for sxcmd in self.sxcmd_category.cmd_list: sxcmd.widget.quit_all_child_applications() + # ======================================================================================== # Layout of the project constants parameters widget; owned by the main window class SXConstSetWidget(QWidget): @@ -3425,27 +3981,39 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) self.gui_settings_file_path = "%s/gui_settings_project_%d.txt" % (SXLookFeelConst.project_dir, int(helical)) # Layout constants and variables - global_row_origin = 0; global_col_origin = 0 - global_row_span = 4; global_col_span = 1 - - header_row_origin = 0; header_col_origin = 0 - title_row_span = 1; title_col_span = 1 - short_info_row_span = 1; short_info_col_span = 1 + global_row_origin = 0; + global_col_origin = 0 + global_row_span = 4; + global_col_span = 1 + + header_row_origin = 0; + header_col_origin = 0 + title_row_span = 1; + title_col_span = 1 + short_info_row_span = 1; + short_info_col_span = 1 title_min_width = 300 short_info_min_width = 300 short_info_min_height = 80 - const_set_row_origin = 0; const_set_col_origin = 0 - const_label_row_span = 1; const_label_col_span = 1 - const_register_widget_row_span = 1; const_register_widget_col_span = 1 - const_widget_row_span = 1; const_widget_col_span = 1 + const_set_row_origin = 0; + const_set_col_origin = 0 + const_label_row_span = 1; + const_label_col_span = 1 + const_register_widget_row_span = 1; + const_register_widget_col_span = 1 + const_widget_row_span = 1; + const_widget_col_span = 1 const_label_min_width = 150 const_register_widget_min_width = const_label_min_width const_widget_min_width = const_label_min_width - btn_row_origin = 0; btn_col_origin = 0 - func_btn_row_span = 1; func_btn_col_span = 1 - register_btn_row_span = 1; register_btn_col_span = 2 + btn_row_origin = 0; + btn_col_origin = 0 + func_btn_row_span = 1; + func_btn_col_span = 1 + register_btn_row_span = 1; + register_btn_col_span = 2 func_btn_min_width = 50 # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -3456,20 +4024,24 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) self.setPalette(palette) global_layout = QGridLayout() - global_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + global_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) global_layout.setSpacing(SXLookFeelConst.grid_spacing) global_layout.setRowStretch(global_row_span - 1, global_layout.rowStretch(global_row_origin) + 1) header_layout = QGridLayout() - header_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + header_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) header_layout.setSpacing(SXLookFeelConst.grid_spacing) const_set_layout = QGridLayout() - const_set_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + const_set_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) const_set_layout.setSpacing(SXLookFeelConst.grid_spacing) btn_layout = QGridLayout() - btn_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + btn_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) btn_layout.setSpacing(SXLookFeelConst.grid_spacing * 2) global_grid_row = global_row_origin @@ -3491,7 +4063,8 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) temp_label.setWordWrap(True) temp_label.setMinimumWidth(short_info_min_width) temp_label.setMinimumHeight(short_info_min_height) - header_layout.addWidget(temp_label, header_grid_row, header_col_origin, short_info_row_span, short_info_col_span) + header_layout.addWidget(temp_label, header_grid_row, header_col_origin, short_info_row_span, + short_info_col_span) # Add const set grid layout to global layout global_layout.addLayout(header_layout, global_grid_row, global_col_origin) @@ -3505,21 +4078,26 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) # Create widget associated to this project constant parameter temp_label = QLabel(sxconst.label) temp_label.setMinimumWidth(const_label_min_width) - const_set_layout.addWidget(temp_label, const_set_grid_row, const_set_col_origin, const_label_row_span, const_label_col_span) + const_set_layout.addWidget(temp_label, const_set_grid_row, const_set_col_origin, const_label_row_span, + const_label_col_span) sxconst_register_widget = QPushButton("%s" % sxconst.register) sxconst_register_widget.setMinimumWidth(const_register_widget_min_width) custom_style = "QPushButton {color:green; }" sxconst_register_widget.setStyleSheet(custom_style) - const_set_layout.addWidget(sxconst_register_widget, const_set_grid_row, const_set_row_origin + const_label_col_span, const_register_widget_row_span, const_register_widget_col_span) - sxconst_register_widget.setToolTip(''+"Retrieve this registered value to edit box"+'') + const_set_layout.addWidget(sxconst_register_widget, const_set_grid_row, + const_set_row_origin + const_label_col_span, const_register_widget_row_span, + const_register_widget_col_span) + sxconst_register_widget.setToolTip('' + "Retrieve this registered value to edit box" + '') sxconst_register_widget.clicked.connect(partial(self.handle_regster_widget_event, sxconst)) sxconst_widget = QLineEdit() sxconst_widget.setMinimumWidth(const_widget_min_width) sxconst_widget.setText(sxconst.register) - sxconst_widget.setToolTip(''+sxconst.help+'') - const_set_layout.addWidget(sxconst_widget, const_set_grid_row, const_set_row_origin + const_label_col_span + const_register_widget_col_span, const_widget_row_span, const_widget_col_span) + sxconst_widget.setToolTip('' + sxconst.help + '') + const_set_layout.addWidget(sxconst_widget, const_set_grid_row, + const_set_row_origin + const_label_col_span + const_register_widget_col_span, + const_widget_row_span, const_widget_col_span) const_set_grid_row += 1 @@ -3540,25 +4118,29 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) custom_style = "QPushButton {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #8D0);min-width:90px;margin:5px} QPushButton:pressed {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #084);min-width:90px;margin:5px}" self.execute_btn.setStyleSheet(custom_style) self.execute_btn.setMinimumWidth(func_btn_min_width * register_btn_col_span) - self.execute_btn.setToolTip(''+"Register project constant parameter settings to automatically set values to command arguments and options"+'') + self.execute_btn.setToolTip( + '' + "Register project constant parameter settings to automatically set values to command arguments and options" + '') self.execute_btn.clicked.connect(self.register_const_set) - btn_layout.addWidget(self.execute_btn, btn_grid_row, btn_col_origin, register_btn_row_span, register_btn_col_span) + btn_layout.addWidget(self.execute_btn, btn_grid_row, btn_col_origin, register_btn_row_span, + register_btn_col_span) btn_grid_row += 1 # Add save project constant parameter settings button self.save_consts_btn = QPushButton("Save settings") self.save_consts_btn.setMinimumWidth(func_btn_min_width) - self.save_consts_btn.setToolTip(''+"Save project constant parameter settings"+'') + self.save_consts_btn.setToolTip('' + "Save project constant parameter settings" + '') self.save_consts_btn.clicked.connect(self.save_consts) btn_layout.addWidget(self.save_consts_btn, btn_grid_row, btn_col_origin, func_btn_row_span, func_btn_col_span) # Add load project constant parameter settings button self.load_consts_btn = QPushButton("Load settings") self.load_consts_btn.setMinimumWidth(func_btn_min_width) - self.load_consts_btn.setToolTip(''+"Load project constant parameter settings to retrieve the previously-saved one"+'') + self.load_consts_btn.setToolTip( + '' + "Load project constant parameter settings to retrieve the previously-saved one" + '') self.load_consts_btn.clicked.connect(self.load_consts) - btn_layout.addWidget(self.load_consts_btn, btn_grid_row, btn_col_origin + func_btn_col_span, func_btn_row_span, func_btn_col_span) + btn_layout.addWidget(self.load_consts_btn, btn_grid_row, btn_col_origin + func_btn_col_span, func_btn_row_span, + func_btn_col_span) btn_grid_row += 1 btn_layout.addWidget(QLabel(), btn_grid_row, btn_col_origin, register_btn_row_span, register_btn_col_span) @@ -3578,7 +4160,8 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) # make 3D textured push button look self.helical_spa_btn.setMinimumWidth(func_btn_min_width * register_btn_col_span) self.helical_spa_btn.clicked.connect(self.switch_gui) - btn_layout.addWidget(self.helical_spa_btn, btn_grid_row, btn_col_origin, register_btn_row_span, register_btn_col_span) + btn_layout.addWidget(self.helical_spa_btn, btn_grid_row, btn_col_origin, register_btn_row_span, + register_btn_col_span) btn_grid_row += 1 @@ -3601,7 +4184,8 @@ def __init__(self, sxconst_set, sxcmd_category_list, helical=False, parent=None) def switch_gui(self): self.parent.helical = not self.parent.helical self.parent.sxmenu_item_widget_stacked_layout_global.setCurrentIndex(self.parent.helical) - self.parent.sxmenu_item_widget_stacked_layout[self.parent.helical].setCurrentWidget(self.parent.sxconst_set[self.parent.helical].widget) + self.parent.sxmenu_item_widget_stacked_layout[self.parent.helical].setCurrentWidget( + self.parent.sxconst_set[self.parent.helical].widget) def handle_regster_widget_event(self, sxconst): sxconst.widget.setText(sxconst.register) @@ -3626,27 +4210,27 @@ def register_const_set(self): except: cmd_token.restore_widget.setCurrentIndex(0) cmd_token.widget.setText(cmd_token.restore) - # print "MRK_DEBUG: %s, %s, %s, %s, %s, %s" % (sxcmd.name, sxcmd.subname, cmd_token.key_base, cmd_token.type, cmd_token.default, cmd_token.restore) + # print "MRK_DEBUG: %s, %s, %s, %s, %s, %s" % (sxcmd.name, sxcmd.subname, cmd_token.key_base, cmd_token.type, cmd_token.default, cmd_token.restore) elif cmd_token.type == "abs_freq": - assert("apix" in list(self.sxconst_set.dict.keys())) -### print("MRK_DEBUG: ----- register_const_set() ----- ") -### print("MRK_DEBUG: cmd_token.type = {}".format(cmd_token.type)) -### sxconst_apix = self.sxconst_set.dict["apix"] -### print("MRK_DEBUG: sxconst_apix.type = {}".format(sxconst_apix.type)) -### print("MRK_DEBUG: sxconst_apix.register = {}".format(sxconst_apix.register)) -### assert (cmd_token.subwidget_left is not None) -### assert (cmd_token.subwidget_right is not None) + assert ("apix" in list(self.sxconst_set.dict.keys())) + ### print("MRK_DEBUG: ----- register_const_set() ----- ") + ### print("MRK_DEBUG: cmd_token.type = {}".format(cmd_token.type)) + ### sxconst_apix = self.sxconst_set.dict["apix"] + ### print("MRK_DEBUG: sxconst_apix.type = {}".format(sxconst_apix.type)) + ### print("MRK_DEBUG: sxconst_apix.register = {}".format(sxconst_apix.register)) + ### assert (cmd_token.subwidget_left is not None) + ### assert (cmd_token.subwidget_right is not None) assert (cmd_token.calculator_dialog is not None) -### sxoperand_apix = cmd_token.calculator_dialog.sxoperand_set.dict["apix"] -### print("MRK_DEBUG: BEFORE sxoperand_apix.register = {}".format(sxoperand_apix.register)) -### print("MRK_DEBUG: BEFORE sxoperand_apix.register_widget.text() = {}".format(sxoperand_apix.register_widget.text())) -### print("MRK_DEBUG: BEFORE sxoperand_apix.widget.text() = {}".format(sxoperand_apix.widget.text())) -### sxoperand_apix.register = sxconst_apix.register -### sxoperand_apix.register_widget.setText("%s" % sxoperand_apix.register) -### sxoperand_apix.widget.setText(sxoperand_apix.register) -### print("MRK_DEBUG: AFTER sxoperand_apix.register = {}".format(sxoperand_apix.register)) -### print("MRK_DEBUG: AFTER sxoperand_apix.register_widget.text() = {}".format(sxoperand_apix.register_widget.text())) -### print("MRK_DEBUG: AFTER sxoperand_apix.widget.text() = {}".format(sxoperand_apix.widget.text())) + ### sxoperand_apix = cmd_token.calculator_dialog.sxoperand_set.dict["apix"] + ### print("MRK_DEBUG: BEFORE sxoperand_apix.register = {}".format(sxoperand_apix.register)) + ### print("MRK_DEBUG: BEFORE sxoperand_apix.register_widget.text() = {}".format(sxoperand_apix.register_widget.text())) + ### print("MRK_DEBUG: BEFORE sxoperand_apix.widget.text() = {}".format(sxoperand_apix.widget.text())) + ### sxoperand_apix.register = sxconst_apix.register + ### sxoperand_apix.register_widget.setText("%s" % sxoperand_apix.register) + ### sxoperand_apix.widget.setText(sxoperand_apix.register) + ### print("MRK_DEBUG: AFTER sxoperand_apix.register = {}".format(sxoperand_apix.register)) + ### print("MRK_DEBUG: AFTER sxoperand_apix.register_widget.text() = {}".format(sxoperand_apix.register_widget.text())) + ### print("MRK_DEBUG: AFTER sxoperand_apix.widget.text() = {}".format(sxoperand_apix.widget.text())) cmd_token.calculator_dialog.reflect_external_global_update_apix() # Save the current state of GUI settings @@ -3655,11 +4239,11 @@ def register_const_set(self): self.write_consts(self.gui_settings_file_path) def write_consts(self, file_path_out): - file_out = open(file_path_out,"w") + file_out = open(file_path_out, "w") # Write script name for consistency check upon loading file_out.write("@@@@@ project settings gui settings - ") - file_out.write(EMANVERSION + " (GITHUB: " + DATESTAMP +")" ) + file_out.write(EMANVERSION + " (GITHUB: " + DATESTAMP + ")") file_out.write(" @@@@@ \n") # Loop through all project constant parameters @@ -3671,7 +4255,7 @@ def write_consts(self, file_path_out): file_out.close() def read_consts(self, file_path_in): - file_in = open(file_path_in,"r") + file_in = open(file_path_in, "r") # Check if this parameter file is for this sx script line_in = file_in.readline() @@ -3689,25 +4273,33 @@ def read_consts(self, file_path_in): target_operator = "<" item_tail = label_in.find(target_operator) if item_tail != 0: - QMessageBox.warning(self, "Invalid Project Settings File Format", "Project settings entry should start from \"%s\" for entry key in line (%s). The format of this file might be corrupted. Please save the project settings file again." % (target_operator, line_in)) - label_in = label_in[item_tail + len(target_operator):].strip() # Get the rest of line + QMessageBox.warning(self, "Invalid Project Settings File Format", + "Project settings entry should start from \"%s\" for entry key in line (%s). The format of this file might be corrupted. Please save the project settings file again." % ( + target_operator, line_in)) + label_in = label_in[item_tail + len(target_operator):].strip() # Get the rest of line target_operator = ">" item_tail = label_in.find(target_operator) if item_tail == -1: - QMessageBox.warning(self, "Invalid Project Settings File Format", "Project settings entry should have \"%s\" closing entry key in line (%s) The format of this file might be corrupted. Please save the project settings file again." % (target_operator, line_in)) + QMessageBox.warning(self, "Invalid Project Settings File Format", + "Project settings entry should have \"%s\" closing entry key in line (%s) The format of this file might be corrupted. Please save the project settings file again." % ( + target_operator, line_in)) key = label_in[0:item_tail] # Get corresponding sxconst if key not in list(self.sxconst_set.dict.keys()): - QMessageBox.warning(self, "Invalid Project Settings File Format", "Invalid entry key for project settings \"%s\" is found in line (%s). This project settings file might be incompatible with the current version. Please save the project settings file again." % (key, line_in)) + QMessageBox.warning(self, "Invalid Project Settings File Format", + "Invalid entry key for project settings \"%s\" is found in line (%s). This project settings file might be incompatible with the current version. Please save the project settings file again." % ( + key, line_in)) sxconst = self.sxconst_set.dict[key] sxconst.widget.setText(val_str_in) else: - QMessageBox.warning(self, "Fail to load project settings", "The specified file is not project settings file.") + QMessageBox.warning(self, "Fail to load project settings", + "The specified file is not project settings file.") file_in.close() def save_consts(self): - name = QFileDialog.getSaveFileName(self, "Save settings", SXLookFeelConst.file_dialog_dir, options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getSaveFileName(self, "Save settings", SXLookFeelConst.file_dialog_dir, + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -3716,7 +4308,8 @@ def save_consts(self): self.write_consts(file_path) def load_consts(self): - name = QFileDialog.getOpenFileName(self, "Load settings", SXLookFeelConst.file_dialog_dir, options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Load settings", SXLookFeelConst.file_dialog_dir, + options=QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -3724,10 +4317,11 @@ def load_consts(self): if file_path != "": self.read_consts(file_path) + # ======================================================================================== # Layout of the information widget; owned by the main window class SXInfoWidget(QWidget): - def __init__(self, parent = None): + def __init__(self, parent=None): super(SXInfoWidget, self).__init__(parent) self.setStyleSheet("background-color: {0}".format(SXLookFeelConst.default_bg_color_string)) @@ -3786,20 +4380,21 @@ def __init__(self, parent = None): layout.addWidget(widget) layout.setContentsMargins(0, 0, 0, 0) + """ # ======================================================================================== class SXDialogCalculator(QDialog): def __init__(self, parent = None): super(QDialog, self).__init__(parent) - + self.setWindowModality(Qt.ApplicationModal) - + # self.setWindowTitle() self.setWindowTitle("Absolute Frequency Calculator") temp_label = QLabel("Calculate absolute frequency [1/Pixel] from resolution [A]", self) temp_label.move(50,50) - + # Create label widget temp_label = QLabel("Resolution [A]", self) # temp_label.setMinimumWidth(token_label_min_width) @@ -3816,16 +4411,17 @@ def __init__(self, parent = None): self.edit_apix = QLineEdit(self) self.edit_apix.setText('Enter Pixel Size Here') self.edit_apix.move(200,200) - + self.btn_apply = QPushButton("Apply", self) self.btn_apply.move(50,300) self.btn_cancel = QPushButton("Cancel", self) self.btn_cancel.move(200,300) # self.connect(cmd_token_restore_widget[widget_index], SIGNAL("clicked()"), partial(self.handle_restore_widget_event, cmd_token, widget_index)) - + ### self.show() """ + class SXDialogCalculator(QDialog): # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # static class variables @@ -3834,44 +4430,57 @@ class SXDialogCalculator(QDialog): precision_abs_freq = 7 precision_ares = 2 - def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sxcmd_token_subwidget_left_ares, parent = None): + def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sxcmd_token_subwidget_left_ares, + parent=None): super(QDialog, self).__init__(parent) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # class variables self.sxoperand_set = self.construct_sxoperand_set() - self.sxconst_register_widget_apix = sxconst_register_widget_apix # SXconst.register_widget of apix type + self.sxconst_register_widget_apix = sxconst_register_widget_apix # SXconst.register_widget of apix type self.sxcmd_token_widget_abs_freq = sxcmd_token_widget_abs_freq self.sxcmd_token_subwidget_left_ares = sxcmd_token_subwidget_left_ares # This have to be set upon the construction order... - self.sxcmd_token_widget_apix = None # SXcmd_token.widget of apix type if this command has one - self.sxcmd_token_other_dialog_list_abs_freq = [] # SXcmd_token.other_dialog_list of the associated abs_freq type token if this command has more than one abs_freq type tokens - + self.sxcmd_token_widget_apix = None # SXcmd_token.widget of apix type if this command has one + self.sxcmd_token_other_dialog_list_abs_freq = [] # SXcmd_token.other_dialog_list of the associated abs_freq type token if this command has more than one abs_freq type tokens + # This should be a modal dialog self.setWindowModality(Qt.ApplicationModal) self.setWindowTitle("%s" % (self.sxoperand_set.label)) # Layout constants and variables - global_row_origin = 0; global_col_origin = 0 - global_row_span = 4; global_col_span = 1 - - header_row_origin = 0; header_col_origin = 0 - title_row_span = 1; title_col_span = 1 - short_info_row_span = 1; short_info_col_span = 1 + global_row_origin = 0; + global_col_origin = 0 + global_row_span = 4; + global_col_span = 1 + + header_row_origin = 0; + header_col_origin = 0 + title_row_span = 1; + title_col_span = 1 + short_info_row_span = 1; + short_info_col_span = 1 title_min_width = 300 short_info_min_width = 300 short_info_min_height = 80 - operand_set_row_origin = 0; operand_set_col_origin = 0 - operand_label_row_span = 1; operand_label_col_span = 1 - operand_register_widget_row_span = 1; operand_register_widget_col_span = 1 - operand_widget_row_span = 1; operand_widget_col_span = 1 + operand_set_row_origin = 0; + operand_set_col_origin = 0 + operand_label_row_span = 1; + operand_label_col_span = 1 + operand_register_widget_row_span = 1; + operand_register_widget_col_span = 1 + operand_widget_row_span = 1; + operand_widget_col_span = 1 operand_label_min_width = 150 operand_register_widget_min_width = operand_label_min_width operand_widget_min_width = operand_label_min_width - btn_row_origin = 0; btn_col_origin = 0 - func_btn_row_span = 1; func_btn_col_span = 1 - register_btn_row_span = 1; register_btn_col_span = 2 + btn_row_origin = 0; + btn_col_origin = 0 + func_btn_row_span = 1; + func_btn_col_span = 1 + register_btn_row_span = 1; + register_btn_col_span = 2 func_btn_min_width = 50 # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< # background_image_file_path = '{0}sxgui_background.png'.format(get_image_directory()) @@ -3884,46 +4493,49 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx self.setPalette(palette) global_layout = QGridLayout() - global_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + global_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) global_layout.setSpacing(SXLookFeelConst.grid_spacing) global_layout.setRowStretch(global_row_span - 1, global_layout.rowStretch(global_row_origin) + 1) -# header_layout = QGridLayout() -# header_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) -# header_layout.setSpacing(SXLookFeelConst.grid_spacing) + # header_layout = QGridLayout() + # header_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + # header_layout.setSpacing(SXLookFeelConst.grid_spacing) operand_layout = QGridLayout() - operand_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + operand_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) operand_layout.setSpacing(SXLookFeelConst.grid_spacing) btn_layout = QGridLayout() - btn_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) + btn_layout.setContentsMargins(SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin, + SXLookFeelConst.grid_margin, SXLookFeelConst.grid_margin) btn_layout.setSpacing(SXLookFeelConst.grid_spacing * 2) global_grid_row = global_row_origin -# # Start add title widgets to the grid layout -# header_grid_row = header_row_origin -# -# # Set a label and its position in this dialog -# temp_label = QLabel("%s" % (self.sxoperand_set.label)) -# temp_label.setMinimumWidth(title_min_width) -# header_layout.addWidget(temp_label, header_grid_row, header_col_origin, title_row_span, title_col_span) -# -# header_grid_row += 1 - -# # NOTE: 2015/11/17 Toshio Moriya -# # Necessary to separate "%s" from the information for avoiding to invoke the tag interpretations of string -# # e.g. < becomes the escape character -# temp_label = QLabel("%s" % (self.sxoperand_set.short_info)) -# temp_label.setWordWrap(True) -# temp_label.setMinimumWidth(short_info_min_width) -# temp_label.setMinimumHeight(short_info_min_height) -# header_layout.addWidget(temp_label, header_grid_row, header_col_origin, short_info_row_span, short_info_col_span) -# -# # Add const set grid layout to global layout -# global_layout.addLayout(header_layout, global_grid_row, global_col_origin) -# global_grid_row += 1 + # # Start add title widgets to the grid layout + # header_grid_row = header_row_origin + # + # # Set a label and its position in this dialog + # temp_label = QLabel("%s" % (self.sxoperand_set.label)) + # temp_label.setMinimumWidth(title_min_width) + # header_layout.addWidget(temp_label, header_grid_row, header_col_origin, title_row_span, title_col_span) + # + # header_grid_row += 1 + + # # NOTE: 2015/11/17 Toshio Moriya + # # Necessary to separate "%s" from the information for avoiding to invoke the tag interpretations of string + # # e.g. < becomes the escape character + # temp_label = QLabel("%s" % (self.sxoperand_set.short_info)) + # temp_label.setWordWrap(True) + # temp_label.setMinimumWidth(short_info_min_width) + # temp_label.setMinimumHeight(short_info_min_height) + # header_layout.addWidget(temp_label, header_grid_row, header_col_origin, short_info_row_span, short_info_col_span) + # + # # Add const set grid layout to global layout + # global_layout.addLayout(header_layout, global_grid_row, global_col_origin) + # global_grid_row += 1 # Start add project parameter constant widgets to the grid layout operand_grid_row = operand_set_row_origin @@ -3933,32 +4545,37 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx # Create widget associated to this project constant parameter temp_label = QLabel(sxoperand.label) temp_label.setMinimumWidth(operand_label_min_width) - operand_layout.addWidget(temp_label, operand_grid_row, operand_set_col_origin, operand_label_row_span, operand_label_col_span) + operand_layout.addWidget(temp_label, operand_grid_row, operand_set_col_origin, operand_label_row_span, + operand_label_col_span) sxoperand_register_widget = QPushButton("%s" % sxoperand.register) sxoperand_register_widget.setMinimumWidth(operand_register_widget_min_width) custom_style = "" if sxoperand.is_input: if sxoperand.type in ["apix"]: - custom_style = "QPushButton {color:green; }" # custom_style = "QPushButton {font: normal; color:black;}" + custom_style = "QPushButton {color:green; }" # custom_style = "QPushButton {font: normal; color:black;}" sxoperand_register_widget.setStyleSheet(custom_style) - sxoperand_register_widget.setToolTip(''+"Retrieve this default value to edit box"+'') + sxoperand_register_widget.setToolTip('' + "Retrieve this default value to edit box" + '') sxoperand_register_widget.clicked.connect(partial(self.handle_regster_widget_event, sxoperand)) else: assert (not sxoperand.is_input) custom_style = "QPushButton {background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid;}" sxoperand_register_widget.setStyleSheet(custom_style) sxoperand_register_widget.setEnabled(False) - operand_layout.addWidget(sxoperand_register_widget, operand_grid_row, operand_set_row_origin + operand_label_col_span, operand_register_widget_row_span, operand_register_widget_col_span) + operand_layout.addWidget(sxoperand_register_widget, operand_grid_row, + operand_set_row_origin + operand_label_col_span, operand_register_widget_row_span, + operand_register_widget_col_span) sxoperand_widget = QLineEdit() sxoperand_widget.setMinimumWidth(operand_widget_min_width) sxoperand_widget.setText(sxoperand.register) - sxoperand_widget.setToolTip(''+sxoperand.help+'') - operand_layout.addWidget(sxoperand_widget, operand_grid_row, operand_set_row_origin + operand_label_col_span + operand_register_widget_col_span, operand_widget_row_span, operand_widget_col_span) + sxoperand_widget.setToolTip('' + sxoperand.help + '') + operand_layout.addWidget(sxoperand_widget, operand_grid_row, + operand_set_row_origin + operand_label_col_span + operand_register_widget_col_span, + operand_widget_row_span, operand_widget_col_span) if not sxoperand.is_input: sxoperand_widget.setEnabled(False) - + operand_grid_row += 1 # Register this widget @@ -3975,7 +4592,7 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx # Add save project constant parameter settings button self.convert_units_btn = QPushButton("Convert units") self.convert_units_btn.setMinimumWidth(func_btn_min_width) - self.convert_units_btn.setToolTip(''+"Calculate unit conversion"+'') + self.convert_units_btn.setToolTip('' + "Calculate unit conversion" + '') self.convert_units_btn.setDefault(True); self.convert_units_btn.clicked.connect(self.handle_convert_units) btn_layout.addWidget(self.convert_units_btn, btn_grid_row, btn_col_origin, func_btn_row_span, func_btn_col_span) @@ -3983,30 +4600,33 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx # Add load project constant parameter settings button self.cancel_btn = QPushButton("Cancel") self.cancel_btn.setMinimumWidth(func_btn_min_width) - self.cancel_btn.setToolTip(''+"Cancel the unit convertion. Close the calculator dialog without applying the converted value to the associated edit box"+'') + self.cancel_btn.setToolTip( + '' + "Cancel the unit convertion. Close the calculator dialog without applying the converted value to the associated edit box" + '') self.cancel_btn.clicked.connect(self.close) - btn_layout.addWidget(self.cancel_btn, btn_grid_row, btn_col_origin + func_btn_col_span, func_btn_row_span, func_btn_col_span) + btn_layout.addWidget(self.cancel_btn, btn_grid_row, btn_col_origin + func_btn_col_span, func_btn_row_span, + func_btn_col_span) btn_grid_row += 1 -### # For now, initialise with Nyquist resolution of 1.0 [A] pixel size -### self.apix_str = self.sxconst_register_widget_apix.text() -### self.abs_freq_str = self.sxcmd_token_widget_abs_freq.text() -### self.convert_abs_freq_to_ares() -### sxoperand_apix = self.sxoperand_set.dict["apix"] -### sxoperand_apix.register = apix_str -### sxoperand_apix.widget.setText(sxoperand_apix.register) -### sxoperand_ares = self.sxoperand_set.dict["ares"] -### sxoperand_ares.register = ares_str -### sxoperand_ares.widget.setText(sxoperand_ares.register) - + ### # For now, initialise with Nyquist resolution of 1.0 [A] pixel size + ### self.apix_str = self.sxconst_register_widget_apix.text() + ### self.abs_freq_str = self.sxcmd_token_widget_abs_freq.text() + ### self.convert_abs_freq_to_ares() + ### sxoperand_apix = self.sxoperand_set.dict["apix"] + ### sxoperand_apix.register = apix_str + ### sxoperand_apix.widget.setText(sxoperand_apix.register) + ### sxoperand_ares = self.sxoperand_set.dict["ares"] + ### sxoperand_ares.register = ares_str + ### sxoperand_ares.widget.setText(sxoperand_ares.register) + # Add a apply button self.apply_btn = QPushButton("Apply") # make 3D textured push button look custom_style = "QPushButton {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #8D0)} QPushButton:pressed {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #084)} QPushButton:focus {font: bold; color: #000;border: 2px solid #8D0;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #8D0)} QPushButton:disabled {font: bold; color: #000;border: 1px solid #333;border-radius: 11px;padding: 2px;background: qradialgradient(cx: 0, cy: 0,fx: 0.5, fy:0.5,radius: 1, stop: 0 #fff, stop: 1 #ff0000)}" self.apply_btn.setStyleSheet(custom_style) self.apply_btn.setMinimumWidth(func_btn_min_width * register_btn_col_span) - self.apply_btn.setToolTip(''+"Apply converted value to the corresponding command arguments and options"+'') + self.apply_btn.setToolTip( + '' + "Apply converted value to the corresponding command arguments and options" + '') self.apply_btn.clicked.connect(self.handle_apply_unit_conversion) btn_layout.addWidget(self.apply_btn, btn_grid_row, btn_col_origin, register_btn_row_span, register_btn_col_span) @@ -4015,9 +4635,9 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx # Add button grid layout to global layout # global_layout.addLayout(btn_layout, global_grid_row, global_col_origin) # Maybe later :) -# # Load the previously saved parameter setting of this sx command -# if os.path.exists(self.gui_settings_file_path): -# self.read_consts(self.gui_settings_file_path) + # # Load the previously saved parameter setting of this sx command + # if os.path.exists(self.gui_settings_file_path): + # self.read_consts(self.gui_settings_file_path) # Layout for a constant size constant_height_layout = QVBoxLayout() @@ -4027,105 +4647,130 @@ def __init__(self, sxconst_register_widget_apix, sxcmd_token_widget_abs_freq, sx constant_width_layout = QHBoxLayout(self) constant_width_layout.addLayout(constant_height_layout) constant_width_layout.addStretch(1) - + # Synchronise the initial status of operands in this dialog - self.handle_convert_units(is_enable_message = False) - + self.handle_convert_units(is_enable_message=False) + def construct_sxoperand_set(self): - sxoperand_set = SXoperand_set(); sxoperand_set.name = "sxc_calculator"; sxoperand_set.label = "Absolute Frequency Calculator"; sxoperand_set.short_info = "From resolution [A] (ares), calculate absolute frequency [1/Pixel] (abs_freq) using a give pixel size [A/Pixel] (apix), where abs_freq = apix/ares." - sxoperand = SXoperand(); sxoperand.key = "ares"; sxoperand.label = "Resolution [A]"; sxoperand.help = "Resolution [A] to calculate the corresponding absolute frequency [1/Pixel] using a given pixel size [A/Pixel]."; sxoperand.register = " -9999.9"; sxoperand.type = "float"; sxoperand_set.list.append(sxoperand); sxoperand_set.dict[sxoperand.key] = sxoperand - sxoperand = SXoperand(); sxoperand.key = "apix"; sxoperand.label = "Pixel size [A/Pixel]"; sxoperand.help = "Pixel size of dataset [A/Pixel]."; sxoperand.register = " -9999.9"; sxoperand.type = "apix"; sxoperand_set.list.append(sxoperand); sxoperand_set.dict[sxoperand.key] = sxoperand - sxoperand = SXoperand(); sxoperand.key = "abs_freq"; sxoperand.label = "Absolute Frequency [1/Pixel]"; sxoperand.help = "Absolute frquency [1/Pixel] corresponding to the given resolution [A/Pixel]."; sxoperand.register = " -9999.9"; sxoperand.type = "abs_freq"; sxoperand.is_input = False; sxoperand_set.list.append(sxoperand); sxoperand_set.dict[sxoperand.key] = sxoperand + sxoperand_set = SXoperand_set(); + sxoperand_set.name = "sxc_calculator"; + sxoperand_set.label = "Absolute Frequency Calculator"; + sxoperand_set.short_info = "From resolution [A] (ares), calculate absolute frequency [1/Pixel] (abs_freq) using a give pixel size [A/Pixel] (apix), where abs_freq = apix/ares." + sxoperand = SXoperand(); + sxoperand.key = "ares"; + sxoperand.label = "Resolution [A]"; + sxoperand.help = "Resolution [A] to calculate the corresponding absolute frequency [1/Pixel] using a given pixel size [A/Pixel]."; + sxoperand.register = " -9999.9"; + sxoperand.type = "float"; + sxoperand_set.list.append(sxoperand); + sxoperand_set.dict[sxoperand.key] = sxoperand + sxoperand = SXoperand(); + sxoperand.key = "apix"; + sxoperand.label = "Pixel size [A/Pixel]"; + sxoperand.help = "Pixel size of dataset [A/Pixel]."; + sxoperand.register = " -9999.9"; + sxoperand.type = "apix"; + sxoperand_set.list.append(sxoperand); + sxoperand_set.dict[sxoperand.key] = sxoperand + sxoperand = SXoperand(); + sxoperand.key = "abs_freq"; + sxoperand.label = "Absolute Frequency [1/Pixel]"; + sxoperand.help = "Absolute frquency [1/Pixel] corresponding to the given resolution [A/Pixel]."; + sxoperand.register = " -9999.9"; + sxoperand.type = "abs_freq"; + sxoperand.is_input = False; + sxoperand_set.list.append(sxoperand); + sxoperand_set.dict[sxoperand.key] = sxoperand # Store the project constant parameter set as a class data member return sxoperand_set - + def handle_regster_widget_event(self, sxoperand): sxoperand.widget.setText(sxoperand.register) self.handle_convert_units() -### def handle_show_event(self): -### # Use current value of resolution [A] widget as a register value of resolution [A] operand upon showing this dialog -### sxoperand_ares = self.sxoperand_set.dict["ares"] -### sxoperand_ares.register = self.sxcmd_token_subwidget_left_ares.text() -### sxoperand_ares.register_widget.setText("%s" % sxoperand_ares.register) -### sxoperand_ares.widget.setText(sxoperand_ares.register) -### -### # Show this dialog -### self.show() - -### def handle_abs_freq_editing_finished_event(self): -### apix_str = self.sxconst_register_widget_apix.text() -### abs_freq_str = sxcmd_token_widget_abs_freq.text() -### ares_str, is_valid_ares = selft.convert_abs_freq_to_ares(apix_str, abs_freq_str) -### sxoperand_ -### print("MRK_DEBUG: ----- handle_abs_freq_editing_finished_event() ----- ") -### print("MRK_DEBUG: Input Abs. Freq. [1/Pixel] string ; abs_freq_str := {}".format(abs_freq_str)) -### print("MRK_DEBUG: Input Pixel Size [A/Pixel] string ; apix_str := {}".format(apix_str)) -### print("MRK_DEBUG: Output Resolution [A] string ; ares_str:= {}".format(ares_str)) -### if is_valid_ares: -### sxcmd_token_subwidget_left_ares.setText("{}[A]@{}[A/Pix]".format(ares_str, apix_str)) -### else: -### sxcmd_token_subwidget_left_ares.setText("Mode {}".format(ares_str)) - -### def convert_abs_freq_to_ares(): -### # Initialise resolution [A] string to absolute frequency [1/Pixel] string -### self.ares_str = self.abs_freq_str -### self.is_valid_ares = False -### -### # Initialise resolution [A] and pixel size [A/Pixel] with invalid values -### self.abs_freq_str abs_freq = 0.0 -### self.abs_freq_strapix = 0.0 -### # Check data type of arguments -### try: -### self.apix = float(self.apix_str) -### except ValueError: -### # The text string can not be converted to float. This must be special value of this option -### assert (self.ares_str == self.abs_freq_str) -### assert (not self.is_valid_ares) -### return -### try: -### self.abs_freq = float(self.abs_freq_str) -### except ValueError: -### # The text string can not be converted to float. This must be special value of this option -### assert (self.ares_str == self.abs_freq_str) -### assert (not self.is_valid_ares) -### return -### # Check invalid values of arguments -### if self.apix <= 0.0: -### # The valid range of pixel size [A] is apix > 0.0. The valid value must have not been set yet. -### assert (self.ares_str == self.abs_freq_str) -### assert (not self.is_valid_ares) -### return ares_str, self.is_valid_ares -### assert (apix > 0.0) -### if abs_freq <= 0.0 or abs_freq > 0.5: -### # The valid range of absolut frequency is 0.0 < abs_freq <= 0.5. This must be special value of this option -### assert (ares_str == abs_freq_str) -### assert (not is_valid_ares) -### return ares_str, is_valid_ares -### assert (abs_freq > 0.0 or abs_freq <= 0.5) -### -### ares = round(apix/abs_freq, SXDialogCalculator.ares_precision) -### ares_str = "{}".format(ares) -### is_valid_ares = True -### -### print("MRK_DEBUG: ----- convert_abs_freq_to_ares() ----- ") -### print("MRK_DEBUG: Input Abs. Freq. [1/Pixel] ; abs_freq := {}".format(abs_freq)) -### print("MRK_DEBUG: Input Pixel Size [A/Pixel] ; apix := {}".format(apix)) -### print("MRK_DEBUG: Output Resolution [A] ; ares:= {}".format(ares)) -### print("MRK_DEBUG: Output Resolution [A] string ; ares_str:= {}".format(ares_str)) -### -### return ares_str, is_valid_ares - - def handle_convert_units(self, is_enable_message = True): + ### def handle_show_event(self): + ### # Use current value of resolution [A] widget as a register value of resolution [A] operand upon showing this dialog + ### sxoperand_ares = self.sxoperand_set.dict["ares"] + ### sxoperand_ares.register = self.sxcmd_token_subwidget_left_ares.text() + ### sxoperand_ares.register_widget.setText("%s" % sxoperand_ares.register) + ### sxoperand_ares.widget.setText(sxoperand_ares.register) + ### + ### # Show this dialog + ### self.show() + + ### def handle_abs_freq_editing_finished_event(self): + ### apix_str = self.sxconst_register_widget_apix.text() + ### abs_freq_str = sxcmd_token_widget_abs_freq.text() + ### ares_str, is_valid_ares = selft.convert_abs_freq_to_ares(apix_str, abs_freq_str) + ### sxoperand_ + ### print("MRK_DEBUG: ----- handle_abs_freq_editing_finished_event() ----- ") + ### print("MRK_DEBUG: Input Abs. Freq. [1/Pixel] string ; abs_freq_str := {}".format(abs_freq_str)) + ### print("MRK_DEBUG: Input Pixel Size [A/Pixel] string ; apix_str := {}".format(apix_str)) + ### print("MRK_DEBUG: Output Resolution [A] string ; ares_str:= {}".format(ares_str)) + ### if is_valid_ares: + ### sxcmd_token_subwidget_left_ares.setText("{}[A]@{}[A/Pix]".format(ares_str, apix_str)) + ### else: + ### sxcmd_token_subwidget_left_ares.setText("Mode {}".format(ares_str)) + + ### def convert_abs_freq_to_ares(): + ### # Initialise resolution [A] string to absolute frequency [1/Pixel] string + ### self.ares_str = self.abs_freq_str + ### self.is_valid_ares = False + ### + ### # Initialise resolution [A] and pixel size [A/Pixel] with invalid values + ### self.abs_freq_str abs_freq = 0.0 + ### self.abs_freq_strapix = 0.0 + ### # Check data type of arguments + ### try: + ### self.apix = float(self.apix_str) + ### except ValueError: + ### # The text string can not be converted to float. This must be special value of this option + ### assert (self.ares_str == self.abs_freq_str) + ### assert (not self.is_valid_ares) + ### return + ### try: + ### self.abs_freq = float(self.abs_freq_str) + ### except ValueError: + ### # The text string can not be converted to float. This must be special value of this option + ### assert (self.ares_str == self.abs_freq_str) + ### assert (not self.is_valid_ares) + ### return + ### # Check invalid values of arguments + ### if self.apix <= 0.0: + ### # The valid range of pixel size [A] is apix > 0.0. The valid value must have not been set yet. + ### assert (self.ares_str == self.abs_freq_str) + ### assert (not self.is_valid_ares) + ### return ares_str, self.is_valid_ares + ### assert (apix > 0.0) + ### if abs_freq <= 0.0 or abs_freq > 0.5: + ### # The valid range of absolut frequency is 0.0 < abs_freq <= 0.5. This must be special value of this option + ### assert (ares_str == abs_freq_str) + ### assert (not is_valid_ares) + ### return ares_str, is_valid_ares + ### assert (abs_freq > 0.0 or abs_freq <= 0.5) + ### + ### ares = round(apix/abs_freq, SXDialogCalculator.ares_precision) + ### ares_str = "{}".format(ares) + ### is_valid_ares = True + ### + ### print("MRK_DEBUG: ----- convert_abs_freq_to_ares() ----- ") + ### print("MRK_DEBUG: Input Abs. Freq. [1/Pixel] ; abs_freq := {}".format(abs_freq)) + ### print("MRK_DEBUG: Input Pixel Size [A/Pixel] ; apix := {}".format(apix)) + ### print("MRK_DEBUG: Output Resolution [A] ; ares:= {}".format(ares)) + ### print("MRK_DEBUG: Output Resolution [A] string ; ares_str:= {}".format(ares_str)) + ### + ### return ares_str, is_valid_ares + + def handle_convert_units(self, is_enable_message=True): sxoperand_apix = self.sxoperand_set.dict["apix"] apix_str = sxoperand_apix.widget.text() sxoperand_ares = self.sxoperand_set.dict["ares"] ares_str = sxoperand_ares.widget.text() sxoperand_abs_freq = self.sxoperand_set.dict["abs_freq"] - + apix = self.convert_str_to_float_apix(apix_str) - + if apix is None: sxoperand_apix.validated = None sxoperand_ares.validated = None @@ -4133,7 +4778,9 @@ def handle_convert_units(self, is_enable_message = True): sxoperand_abs_freq.widget.setText("Invalid Pixel Size {}".format(apix_str)) self.apply_btn.setEnabled(False) if is_enable_message: - QMessageBox.warning(self, "Invalid Pixel Size [A/Pixel]", "Invalid Value {} for Pixel Size [A/Pixel] is provided. It must be a non-zero positive float value...".format(apix_str)) + QMessageBox.warning(self, "Invalid Pixel Size [A/Pixel]", + "Invalid Value {} for Pixel Size [A/Pixel] is provided. It must be a non-zero positive float value...".format( + apix_str)) else: assert (apix is not None) sxoperand_apix.validated = apix @@ -4146,11 +4793,13 @@ def handle_convert_units(self, is_enable_message = True): sxoperand_abs_freq.widget.setText("Invalid Resolution {}".format(ares_str)) self.apply_btn.setEnabled(False) if is_enable_message: - QMessageBox.warning(self, "Invalid Resolution [A]", "Invalid Value {} for Resolution [A] is provided. It must be a float value, and larger than or equal to Nyquist resolution {} [A] (2.0 * Pixel Size [A/Pixel])...".format(ares_str, nyquist_res_str)) + QMessageBox.warning(self, "Invalid Resolution [A]", + "Invalid Value {} for Resolution [A] is provided. It must be a float value, and larger than or equal to Nyquist resolution {} [A] (2.0 * Pixel Size [A/Pixel])...".format( + ares_str, nyquist_res_str)) else: assert (ares >= nyquist_res) sxoperand_ares.validated = ares - abs_freq = round(apix/ares, self.precision_abs_freq) + abs_freq = round(apix / ares, self.precision_abs_freq) # The valid range of absolute frequency [1/Pixel] is 0.0 < abs_freq <= 0.5 # If both pixel size and resolution values are valid, the absolute frequency must be always valid. assert (abs_freq > 0.0 or abs_freq <= 0.5) @@ -4159,57 +4808,56 @@ def handle_convert_units(self, is_enable_message = True): # Update widget associating to absolute frequency [1/Pixel] in this dialog sxoperand_abs_freq.widget.setText(abs_freq_str) self.apply_btn.setEnabled(True) - - -# if sxoperand_apix.validated is None: -# sxoperand_abs_freq.validated = None -# sxoperand_abs_freq.widget.setText("Invalid Pixel Size {}".format(apix_str)) -# self.apply_btn.setEnabled(False) -# if is_enable_message: -# QMessageBox.warning(self, "Invalid Pixel Size [A/Pixel]", "Invalid Value {} for Pixel Size [A/Pixel] is provided. It must be a non-zero positive float value...".format(apix_str)) -# else: -# assert (sxoperand_apix.validated is not None) -# assert (apix > 0.0) -# nyquist_res = 2.0 * apix -# nyquist_res_str = "{}".format(nyquist_res) -# if sxoperand_ares.validated is None: -# sxoperand_abs_freq.validated = None -# sxoperand_abs_freq.widget.setText("Invalid Resolution {}".format(ares_str)) -# self.apply_btn.setEnabled(False) -# if is_enable_message: -# QMessageBox.warning(self, "Invalid Resolution [A]", "Invalid Value {} for Resolution [A] is provided. It must be a float value, and larger than or equal to Nyquist resolution {} [A] (2.0 * Pixel Size [A/Pixel])...".format(ares_str, nyquist_res_str)) -# else: -# assert (sxoperand_apix.validated is not None) -# assert (nyquist_res * 2.0 ) -# abs_freq = round(apix/ares, self.precision_abs_freq) -# # The valid range of absolute frequency [1/Pixel] is 0.0 < abs_freq <= 0.5 -# # If both pixel size and resolution values are valid, the absolute frequency must be always valid. -# assert (abs_freq > 0.0 or abs_freq <= 0.5) -# sxoperand_abs_freq.validated = abs_freq -# abs_freq_str = "{}".format(abs_freq) -# # Update widget associating to absolute frequency [1/Pixel] in this dialog -# sxoperand_abs_freq.widget.setText(abs_freq_str) -# self.apply_btn.setEnabled(True) - - # print("MRK_DEBUG: ") - # print("MRK_DEBUG: ----- SXDialogCalculator.handle_convert_units() ----- ") - # print("MRK_DEBUG: Edit Widget Resolution [A] ; sxoperand_ares.widget.text() := \"{}\"".format(sxoperand_ares.widget.text())) - # print("MRK_DEBUG: Edit Validated Resolution [A] ; sxoperand_ares.validated := \"{}\"".format(sxoperand_ares.validated)) - # print("MRK_DEBUG: Register Widget Resolution [A] ; sxoperand_ares.register_widget.text() := \"{}\"".format(sxoperand_ares.register_widget.text())) - # print("MRK_DEBUG: Register Validated Resolution [A] ; sxoperand_ares.validated_register := \"{}\"".format(sxoperand_ares.validated_register)) - # print("MRK_DEBUG: Register Resolution [A] ; sxoperand_ares.register := \"{}\"".format(sxoperand_ares.register)) - # - # print("MRK_DEBUG: Edit Widget Pixel Size [A/Pixel] ; sxoperand_apix.widget.text() := \"{}\"".format(sxoperand_apix.widget.text())) - # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_apix.validated := \"{}\"".format(sxoperand_apix.validated)) - # print("MRK_DEBUG: Register Widget Pixel Size [A/Pixel] ; sxoperand_apix.register_widget.text() := \"{}\"".format(sxoperand_apix.register_widget.text())) - # print("MRK_DEBUG: Register Validated Pixel Size [A/Pixel] ; sxoperand_apix.validated_register := \"{}\"".format(sxoperand_apix.validated_register)) - # print("MRK_DEBUG: Register Pixel Size [A/Pixel] ; sxoperand_apix.register := \"{}\"".format(sxoperand_apix.register)) - # - # print("MRK_DEBUG: Edit Widget bs. Freq. [1/Pixel] ; sxoperand_abs_freq.widget.text() := \"{}\"".format(sxoperand_abs_freq.widget.text())) - # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated := \"{}\"".format(sxoperand_abs_freq.validated)) - # print("MRK_DEBUG: Register Widget Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register_widget.text() := \"{}\"".format(sxoperand_abs_freq.register_widget.text())) - # print("MRK_DEBUG: Register Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated_register := \"{}\"".format(sxoperand_abs_freq.validated_register)) - # print("MRK_DEBUG: Register Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register := \"{}\"".format(sxoperand_abs_freq.register)) + + # if sxoperand_apix.validated is None: + # sxoperand_abs_freq.validated = None + # sxoperand_abs_freq.widget.setText("Invalid Pixel Size {}".format(apix_str)) + # self.apply_btn.setEnabled(False) + # if is_enable_message: + # QMessageBox.warning(self, "Invalid Pixel Size [A/Pixel]", "Invalid Value {} for Pixel Size [A/Pixel] is provided. It must be a non-zero positive float value...".format(apix_str)) + # else: + # assert (sxoperand_apix.validated is not None) + # assert (apix > 0.0) + # nyquist_res = 2.0 * apix + # nyquist_res_str = "{}".format(nyquist_res) + # if sxoperand_ares.validated is None: + # sxoperand_abs_freq.validated = None + # sxoperand_abs_freq.widget.setText("Invalid Resolution {}".format(ares_str)) + # self.apply_btn.setEnabled(False) + # if is_enable_message: + # QMessageBox.warning(self, "Invalid Resolution [A]", "Invalid Value {} for Resolution [A] is provided. It must be a float value, and larger than or equal to Nyquist resolution {} [A] (2.0 * Pixel Size [A/Pixel])...".format(ares_str, nyquist_res_str)) + # else: + # assert (sxoperand_apix.validated is not None) + # assert (nyquist_res * 2.0 ) + # abs_freq = round(apix/ares, self.precision_abs_freq) + # # The valid range of absolute frequency [1/Pixel] is 0.0 < abs_freq <= 0.5 + # # If both pixel size and resolution values are valid, the absolute frequency must be always valid. + # assert (abs_freq > 0.0 or abs_freq <= 0.5) + # sxoperand_abs_freq.validated = abs_freq + # abs_freq_str = "{}".format(abs_freq) + # # Update widget associating to absolute frequency [1/Pixel] in this dialog + # sxoperand_abs_freq.widget.setText(abs_freq_str) + # self.apply_btn.setEnabled(True) + + # print("MRK_DEBUG: ") + # print("MRK_DEBUG: ----- SXDialogCalculator.handle_convert_units() ----- ") + # print("MRK_DEBUG: Edit Widget Resolution [A] ; sxoperand_ares.widget.text() := \"{}\"".format(sxoperand_ares.widget.text())) + # print("MRK_DEBUG: Edit Validated Resolution [A] ; sxoperand_ares.validated := \"{}\"".format(sxoperand_ares.validated)) + # print("MRK_DEBUG: Register Widget Resolution [A] ; sxoperand_ares.register_widget.text() := \"{}\"".format(sxoperand_ares.register_widget.text())) + # print("MRK_DEBUG: Register Validated Resolution [A] ; sxoperand_ares.validated_register := \"{}\"".format(sxoperand_ares.validated_register)) + # print("MRK_DEBUG: Register Resolution [A] ; sxoperand_ares.register := \"{}\"".format(sxoperand_ares.register)) + # + # print("MRK_DEBUG: Edit Widget Pixel Size [A/Pixel] ; sxoperand_apix.widget.text() := \"{}\"".format(sxoperand_apix.widget.text())) + # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_apix.validated := \"{}\"".format(sxoperand_apix.validated)) + # print("MRK_DEBUG: Register Widget Pixel Size [A/Pixel] ; sxoperand_apix.register_widget.text() := \"{}\"".format(sxoperand_apix.register_widget.text())) + # print("MRK_DEBUG: Register Validated Pixel Size [A/Pixel] ; sxoperand_apix.validated_register := \"{}\"".format(sxoperand_apix.validated_register)) + # print("MRK_DEBUG: Register Pixel Size [A/Pixel] ; sxoperand_apix.register := \"{}\"".format(sxoperand_apix.register)) + # + # print("MRK_DEBUG: Edit Widget bs. Freq. [1/Pixel] ; sxoperand_abs_freq.widget.text() := \"{}\"".format(sxoperand_abs_freq.widget.text())) + # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated := \"{}\"".format(sxoperand_abs_freq.validated)) + # print("MRK_DEBUG: Register Widget Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register_widget.text() := \"{}\"".format(sxoperand_abs_freq.register_widget.text())) + # print("MRK_DEBUG: Register Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated_register := \"{}\"".format(sxoperand_abs_freq.validated_register)) + # print("MRK_DEBUG: Register Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register := \"{}\"".format(sxoperand_abs_freq.register)) def handle_apply_unit_conversion(self): # Do the unit conversion first @@ -4217,13 +4865,15 @@ def handle_apply_unit_conversion(self): sxoperand_abs_freq = self.sxoperand_set.dict["abs_freq"] sxoperand_ares = self.sxoperand_set.dict["ares"] sxoperand_apix = self.sxoperand_set.dict["apix"] - + abs_freq = sxoperand_abs_freq.validated ares = sxoperand_ares.validated apix = sxoperand_apix.validated # This button should have been disabled if all operands are valid if abs_freq is None: - ERROR("Logical Error: Encountered unexpected condition in SXDialogCalculator.handle_apply_unit_conversion(). Consult with the developer.", "%s in %s" % (__name__, os.path.basename(__file__))) + ERROR( + "Logical Error: Encountered unexpected condition in SXDialogCalculator.handle_apply_unit_conversion(). Consult with the developer.", + "%s in %s" % (__name__, os.path.basename(__file__))) self.sxcmd_token_widget_abs_freq.setText("Logical Error") self.sxcmd_token_subwidget_left_ares.setText("Logical Error") else: @@ -4240,18 +4890,18 @@ def handle_apply_unit_conversion(self): # DO NOT update register, validated_register, and register_widget of pixel size [A/Pixel] # These should be updated through only project constants settings - + # Update command token subwidget associating to resolution [A] accordingly self.sxcmd_token_widget_abs_freq.setText(sxoperand_abs_freq.register) self.sxcmd_token_subwidget_left_ares.setText("{}[A]@{}[A/Pix]".format(ares, apix)) - + # Update the associated pixel size token of this command if there is any if self.sxcmd_token_widget_apix is not None: self.sxcmd_token_widget_apix.setText("{}".format(apix)) for sxcmd_token_other_dialog_abs_freq in self.sxcmd_token_other_dialog_list_abs_freq: assert (sxcmd_token_other_dialog_abs_freq is not self) sxcmd_token_other_dialog_abs_freq.reflect_external_local_update_apix() - + # print("MRK_DEBUG: ") # print("MRK_DEBUG: ----- SXDialogCalculator.handle_apply_unit_conversion() ----- ") # print("MRK_DEBUG: Edit Widget Resolution [A] ; sxoperand_ares.widget.text() := \"{}\"".format(sxoperand_ares.widget.text())) @@ -4259,24 +4909,24 @@ def handle_apply_unit_conversion(self): # print("MRK_DEBUG: Register Widget Resolution [A] ; sxoperand_ares.register_widget.text() := \"{}\"".format(sxoperand_ares.register_widget.text())) # print("MRK_DEBUG: Register Validated Resolution [A] ; sxoperand_ares.validated_register := \"{}\"".format(sxoperand_ares.validated_register)) # print("MRK_DEBUG: Register Resolution [A] ; sxoperand_ares.register := \"{}\"".format(sxoperand_ares.register)) - # + # # print("MRK_DEBUG: Edit Widget Pixel Size [A/Pixel] ; sxoperand_apix.widget.text() := \"{}\"".format(sxoperand_apix.widget.text())) # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_apix.validated := \"{}\"".format(sxoperand_apix.validated)) # print("MRK_DEBUG: Register Widget Pixel Size [A/Pixel] ; sxoperand_apix.register_widget.text() := \"{}\"".format(sxoperand_apix.register_widget.text())) # print("MRK_DEBUG: Register Validated Pixel Size [A/Pixel] ; sxoperand_apix.validated_register := \"{}\"".format(sxoperand_apix.validated_register)) # print("MRK_DEBUG: Register Pixel Size [A/Pixel] ; sxoperand_apix.register := \"{}\"".format(sxoperand_apix.register)) - # + # # print("MRK_DEBUG: Edit Widget bs. Freq. [1/Pixel] ; sxoperand_abs_freq.widget.text() := \"{}\"".format(sxoperand_abs_freq.widget.text())) # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated := \"{}\"".format(sxoperand_abs_freq.validated)) # print("MRK_DEBUG: Register Widget Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register_widget.text() := \"{}\"".format(sxoperand_abs_freq.register_widget.text())) # print("MRK_DEBUG: Register Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated_register := \"{}\"".format(sxoperand_abs_freq.validated_register)) # print("MRK_DEBUG: Register Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register := \"{}\"".format(sxoperand_abs_freq.register)) - + self.close() def convert_str_to_float_apix(self, apix_str): # Initialise with easy-to-recognise invalid value, which won't be used. - apix = -9999.9 + apix = -9999.9 # Check data type of string try: apix = float(apix_str) @@ -4322,7 +4972,7 @@ def edit_operand_apix_str(self, apix_str): def convert_str_to_float_abs_freq(self, abs_freq_str): # Initialise with easy-to-recognise invalid value, which won't be used. - abs_freq = -9999.9 + abs_freq = -9999.9 # Check data type of arguments try: abs_freq = float(abs_freq_str) @@ -4331,7 +4981,7 @@ def convert_str_to_float_abs_freq(self, abs_freq_str): return None # round by predefined precision so that calculated resolution [A] is likely to be a simple float value (e.g. 3.0[A]) abs_freq = round(abs_freq, self.precision_abs_freq) - # Check value validity. The valid range of absolut frequency is 0.0 < abs_freq <= 0.5. + # Check value validity. The valid range of absolut frequency is 0.0 < abs_freq <= 0.5. if abs_freq <= 0.0 or abs_freq > 0.5: return None assert (abs_freq > 0.0 or abs_freq <= 0.5) @@ -4353,9 +5003,9 @@ def register_operand_abs_freq_str(self, abs_freq_str): sxoperand_abs_freq.register_widget.setText(sxoperand_abs_freq.register) sxoperand_abs_freq.widget.setText(sxoperand_abs_freq.register) - def convert_str_to_float_ares(self, ares_str, nyquist_res = 0.0): + def convert_str_to_float_ares(self, ares_str, nyquist_res=0.0): # Initialise with easy-to-recognise invalid value, which won't be used. - ares = -9999.9 + ares = -9999.9 # Check data type of arguments try: ares = float(ares_str) @@ -4380,7 +5030,7 @@ def convert_str_to_float_ares(self, ares_str, nyquist_res = 0.0): # sxoperand_ares.validated_register = ares # assert (sxoperand_ares.validated_register is not None) # return - + def synchronize_external_update_to_ares(self): # print("MRK_DEBUG: ----- synchronize_external_update_to_ares ----- ") sxoperand_apix = self.sxoperand_set.dict["apix"] @@ -4403,14 +5053,14 @@ def synchronize_external_update_to_ares(self): assert (sxoperand_apix.validated is not None) apix = sxoperand_apix.validated abs_freq = sxoperand_abs_freq.validated - ares = round(apix/abs_freq, self.precision_ares) + ares = round(apix / abs_freq, self.precision_ares) # The valid range of resolution [A] is ares <= apix * 2.0 (Nyquist resolution) # If both pixel size and absolute frequency values are valid, this must be always true. - assert (ares >= apix * 2.0 ) + assert (ares >= apix * 2.0) sxoperand_ares.validated_register = ares sxoperand_ares.register = "{}".format(sxoperand_ares.validated_register) sxoperand_ares.validated = sxoperand_ares.validated_register - + # Update widgets associating to resolution [A] in this dialog # and command token subwidget associating to resolution [A] if sxoperand_ares.validated_register is not None: @@ -4421,7 +5071,8 @@ def synchronize_external_update_to_ares(self): # Update widget of this command token for absolute frequency [1/Pixel] associating to this dialog self.sxcmd_token_widget_abs_freq.setText("{}".format(sxoperand_abs_freq.register)) # Update left subwidget of this command token for absolute frequency [1/Pixel] associating to this dialog - self.sxcmd_token_subwidget_left_ares.setText("{}[A]@{}[A/Pix]".format(sxoperand_ares.validated, sxoperand_apix.validated)) + self.sxcmd_token_subwidget_left_ares.setText( + "{}[A]@{}[A/Pix]".format(sxoperand_ares.validated, sxoperand_apix.validated)) else: assert (sxoperand_ares.validated_register is None) self.apply_btn.setEnabled(False) @@ -4434,27 +5085,27 @@ def synchronize_external_update_to_ares(self): else: assert (sxoperand_abs_freq.validated is not None) self.sxcmd_token_subwidget_left_ares.setText("{}".format(sxoperand_ares.register)) - - # print("MRK_DEBUG: ") - # print("MRK_DEBUG: ----- SXDialogCalculator.synchronize_external_update_to_ares() ----- ") - # print("MRK_DEBUG: Edit Widget Resolution [A] ; sxoperand_ares.widget.text() := \"{}\"".format(sxoperand_ares.widget.text())) - # print("MRK_DEBUG: Edit Validated Resolution [A] ; sxoperand_ares.validated := \"{}\"".format(sxoperand_ares.validated)) - # print("MRK_DEBUG: Register Widget Resolution [A] ; sxoperand_ares.register_widget.text() := \"{}\"".format(sxoperand_ares.register_widget.text())) - # print("MRK_DEBUG: Register Validated Resolution [A] ; sxoperand_ares.validated_register := \"{}\"".format(sxoperand_ares.validated_register)) - # print("MRK_DEBUG: Register Resolution [A] ; sxoperand_ares.register := \"{}\"".format(sxoperand_ares.register)) - # - # print("MRK_DEBUG: Edit Widget Pixel Size [A/Pixel] ; sxoperand_apix.widget.text() := \"{}\"".format(sxoperand_apix.widget.text())) - # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_apix.validated := \"{}\"".format(sxoperand_apix.validated)) - # print("MRK_DEBUG: Register Widget Pixel Size [A/Pixel] ; sxoperand_apix.register_widget.text() := \"{}\"".format(sxoperand_apix.register_widget.text())) - # print("MRK_DEBUG: Register Validated Pixel Size [A/Pixel] ; sxoperand_apix.validated_register := \"{}\"".format(sxoperand_apix.validated_register)) - # print("MRK_DEBUG: Register Pixel Size [A/Pixel] ; sxoperand_apix.register := \"{}\"".format(sxoperand_apix.register)) - # - # print("MRK_DEBUG: Edit Widget bs. Freq. [1/Pixel] ; sxoperand_abs_freq.widget.text() := \"{}\"".format(sxoperand_abs_freq.widget.text())) - # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated := \"{}\"".format(sxoperand_abs_freq.validated)) - # print("MRK_DEBUG: Register Widget Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register_widget.text() := \"{}\"".format(sxoperand_abs_freq.register_widget.text())) - # print("MRK_DEBUG: Register Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated_register := \"{}\"".format(sxoperand_abs_freq.validated_register)) - # print("MRK_DEBUG: Register Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register := \"{}\"".format(sxoperand_abs_freq.register)) - + + # print("MRK_DEBUG: ") + # print("MRK_DEBUG: ----- SXDialogCalculator.synchronize_external_update_to_ares() ----- ") + # print("MRK_DEBUG: Edit Widget Resolution [A] ; sxoperand_ares.widget.text() := \"{}\"".format(sxoperand_ares.widget.text())) + # print("MRK_DEBUG: Edit Validated Resolution [A] ; sxoperand_ares.validated := \"{}\"".format(sxoperand_ares.validated)) + # print("MRK_DEBUG: Register Widget Resolution [A] ; sxoperand_ares.register_widget.text() := \"{}\"".format(sxoperand_ares.register_widget.text())) + # print("MRK_DEBUG: Register Validated Resolution [A] ; sxoperand_ares.validated_register := \"{}\"".format(sxoperand_ares.validated_register)) + # print("MRK_DEBUG: Register Resolution [A] ; sxoperand_ares.register := \"{}\"".format(sxoperand_ares.register)) + # + # print("MRK_DEBUG: Edit Widget Pixel Size [A/Pixel] ; sxoperand_apix.widget.text() := \"{}\"".format(sxoperand_apix.widget.text())) + # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_apix.validated := \"{}\"".format(sxoperand_apix.validated)) + # print("MRK_DEBUG: Register Widget Pixel Size [A/Pixel] ; sxoperand_apix.register_widget.text() := \"{}\"".format(sxoperand_apix.register_widget.text())) + # print("MRK_DEBUG: Register Validated Pixel Size [A/Pixel] ; sxoperand_apix.validated_register := \"{}\"".format(sxoperand_apix.validated_register)) + # print("MRK_DEBUG: Register Pixel Size [A/Pixel] ; sxoperand_apix.register := \"{}\"".format(sxoperand_apix.register)) + # + # print("MRK_DEBUG: Edit Widget bs. Freq. [1/Pixel] ; sxoperand_abs_freq.widget.text() := \"{}\"".format(sxoperand_abs_freq.widget.text())) + # print("MRK_DEBUG: Edit Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated := \"{}\"".format(sxoperand_abs_freq.validated)) + # print("MRK_DEBUG: Register Widget Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register_widget.text() := \"{}\"".format(sxoperand_abs_freq.register_widget.text())) + # print("MRK_DEBUG: Register Validated Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.validated_register := \"{}\"".format(sxoperand_abs_freq.validated_register)) + # print("MRK_DEBUG: Register Abs. Freq. [1/Pixel] ; sxoperand_abs_freq.register := \"{}\"".format(sxoperand_abs_freq.register)) + def reflect_external_global_update_apix(self): # print("MRK_DEBUG: ") # print("MRK_DEBUG: ----- SXDialogCalculator.reflect_external_global_update_apix() ----- ") @@ -4490,12 +5141,13 @@ def reflect_external_local_update_apix_and_abs_freq(self): self.register_operand_abs_freq_str(abs_freq_str) self.synchronize_external_update_to_ares() + ### @staticmethod ### def convert_ares_to_abs_freq(apix_str, ares_str): ### # Initialise resolution [A] string to absolute frequency [1/Pixel] string ### abs_freq_str = ares_str ### is_valid_abs_freq = False -### +### ### # Initialise resolution [A] and pixel size [A/Pixel] with invalid values ### ares = 0.0 ### apix = 0.0 @@ -4528,17 +5180,17 @@ def reflect_external_local_update_apix_and_abs_freq(self): ### assert (not is_valid_abs_freq) ### return abs_freq_str, is_valid_abs_freq ### assert (ares >= nyquist_res) -### +### ### abs_freq = round(apix/ares, SXDialogCalculator.abs_freq_precision) ### abs_freq_str = "{}".format(abs_freq) ### is_valid_abs_freq = True -### +### ### print("MRK_DEBUG: ----- convert_ares_to_abs_freq() ----- ") ### print("MRK_DEBUG: Input Abs. Freq. [1/Pixel] ; abs_freq := {}".format(abs_freq)) ### print("MRK_DEBUG: Input Pixel Size [A/Pixel] ; apix := {}".format(apix)) ### print("MRK_DEBUG: Output Resolution [A] ; ares:= {}".format(ares)) ### print("MRK_DEBUG: Output Resolution [A] string ; ares_str:= {}".format(ares_str)) -### +### ### return abs_freq_str, is_valid_abs_freq ### def convert_units(self): @@ -4570,10 +5222,10 @@ def reflect_external_local_update_apix_and_abs_freq(self): ### QMessageBox.warning(self, "Invalid Value for Resolution [A]", "Invalid Value {} for Resolution [A] is provided. It must be larger than or equal to the Nyquest resolution {} [A] of the provided pixel size {} [A/Pixel]...".format(ares, nyquist_res, apix)) ### return ### assert (ares >= nyquist_res) -### +### ### self.abs_freq = round(apix/ares, self.abs_freq_precision) ### self.apply_btn.setText("Apply Abs. Freq. {} [1/Pixel]".format(self.abs_freq)) -### +### ### print("MRK_DEBUG: ----- convert_units() ----- ") ### print("MRK_DEBUG: Input Resolution [A] ; ares := {}".format(ares)) ### print("MRK_DEBUG: Input Pixel Size [A/Pixel] ; apix := {}".format(apix)) @@ -4582,9 +5234,9 @@ def reflect_external_local_update_apix_and_abs_freq(self): # ======================================================================================== # Main Window (started by class SXApplication) -class SXMainWindow(QMainWindow): # class SXMainWindow(QWidget): +class SXMainWindow(QMainWindow): # class SXMainWindow(QWidget): - def __init__(self, helical, parent = None): + def __init__(self, helical, parent=None): super(SXMainWindow, self).__init__(parent) # ><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>< @@ -4603,12 +5255,14 @@ def __init__(self, helical, parent = None): # -------------------------------------------------------------------------------- # Construct menu items # -------------------------------------------------------------------------------- - self.sxinfo.append(self.construct_sxinfo()) # Construct application information - self.sxinfo.append(self.construct_sxinfo()) # Construct application information - self.sxconst_set.append(self.construct_sxconst_set(0)) # Construct project constant set for project settings - self.sxconst_set.append(self.construct_sxconst_set(1)) # Construct project constant set for project settings - self.sxcmd_category_list.append(self.construct_sxcmd_category_list()) # Construct list of categorised sxscript objects (extracted from associated wiki documents) - self.sxcmd_category_list.append(self.construct_sxcmd_category_list()) # Construct list of categorised sxscript objects (extracted from associated wiki documents) + self.sxinfo.append(self.construct_sxinfo()) # Construct application information + self.sxinfo.append(self.construct_sxinfo()) # Construct application information + self.sxconst_set.append(self.construct_sxconst_set(0)) # Construct project constant set for project settings + self.sxconst_set.append(self.construct_sxconst_set(1)) # Construct project constant set for project settings + self.sxcmd_category_list.append( + self.construct_sxcmd_category_list()) # Construct list of categorised sxscript objects (extracted from associated wiki documents) + self.sxcmd_category_list.append( + self.construct_sxcmd_category_list()) # Construct list of categorised sxscript objects (extracted from associated wiki documents) # -------------------------------------------------------------------------------- # Setup Window Layout @@ -4619,7 +5273,7 @@ def __init__(self, helical, parent = None): central_widget_global.setObjectName('central') central_widget_global.setStyleSheet( 'QWidget#central {{background-image: url("{0}")}}'.format(background_image_file_path) - ) + ) self.setCentralWidget(central_widget_global) self.sxmenu_item_widget_stacked_layout_global = QStackedLayout() central_widget_global.setLayout(self.sxmenu_item_widget_stacked_layout_global) @@ -4630,7 +5284,7 @@ def __init__(self, helical, parent = None): central_widget.setObjectName('central') central_widget.setStyleSheet( 'QWidget#central {{background-image: url("{0}")}}'.format(background_image_file_path) - ) + ) # Layout for central widget central_layout = QHBoxLayout(central_widget) @@ -4639,7 +5293,8 @@ def __init__(self, helical, parent = None): # -------------------------------------------------------------------------------- # Construct and add a widget for menu item button area (containing all menu item buttons) # -------------------------------------------------------------------------------- - sxmenu_item_btn_area_widget = SXMenuItemBtnAreaWidget(self.sxconst_set[idx], self.sxcmd_category_list[idx], self.sxinfo[idx], idx, central_widget) + sxmenu_item_btn_area_widget = SXMenuItemBtnAreaWidget(self.sxconst_set[idx], self.sxcmd_category_list[idx], + self.sxinfo[idx], idx, central_widget) central_layout.addWidget(sxmenu_item_btn_area_widget) # -------------------------------------------------------------------------------- @@ -4647,10 +5302,11 @@ def __init__(self, helical, parent = None): # -------------------------------------------------------------------------------- # Stacked layout for sx menu item widgets area self.sxmenu_item_widget_stacked_layout.append(QStackedLayout()) - central_layout.addLayout(self.sxmenu_item_widget_stacked_layout[idx], stretch = 1) + central_layout.addLayout(self.sxmenu_item_widget_stacked_layout[idx], stretch=1) # Construct and add a widget for project constants settings - self.sxconst_set[idx].widget = SXConstSetWidget(self.sxconst_set[idx], self.sxcmd_category_list[idx], helical=idx, parent=self) + self.sxconst_set[idx].widget = SXConstSetWidget(self.sxconst_set[idx], self.sxcmd_category_list[idx], + helical=idx, parent=self) self.sxmenu_item_widget_stacked_layout[idx].addWidget(self.sxconst_set[idx].widget) # Construct and add widgets for sx command categories @@ -4690,7 +5346,6 @@ def __init__(self, helical, parent = None): logo_container = QtGui.QWidget() layout_start_widget = QtGui.QHBoxLayout() layout_logo_container = QtGui.QVBoxLayout() - logo_container.setStyleSheet(f'border-image: url("{sp_get_image_path("sxgui_pictograph_info.png")}")') logo_container.setFixedSize(100, 100) layout_start_widget.setContentsMargins(0, 0, 0, 20) @@ -4715,2315 +5370,31772 @@ def __init__(self, helical, parent = None): self.setFocus() def construct_sxinfo(self): -### sxinfo = SXmenu_item(); sxinfo.name = "GUI Information"; sxinfo.label = "GUI Appliation Information"; sxinfo.short_info = "DUMMY STRING" - sxinfo = SXmenu_item(); sxinfo.name = "sxc_gui_info"; sxinfo.label = "GUI Appliation Information"; sxinfo.short_info = "DUMMY STRING" + ### sxinfo = SXmenu_item(); sxinfo.name = "GUI Information"; sxinfo.label = "GUI Appliation Information"; sxinfo.short_info = "DUMMY STRING" + sxinfo = SXmenu_item(); + sxinfo.name = "sxc_gui_info"; + sxinfo.label = "GUI Appliation Information"; + sxinfo.short_info = "DUMMY STRING" # Store GUI application information as a class data member return sxinfo def construct_sxconst_set(self, helical): - sxconst_set = SXconst_set(); sxconst_set.name = "sxc_project"; sxconst_set.label = "Project Settings"; sxconst_set.short_info = "Set constant parameter values for this project. These constants will be used as default values of associated arguments and options in command settings. However, the project settings here are not required to run commands." - sxconst = SXconst(); sxconst.key = "protein"; sxconst.label = "Protein name"; sxconst.help = "a valid string for file names on your OS."; sxconst.register = "MY_PROTEIN"; sxconst.type = "string"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "apix"; sxconst.label = "Micrograph pixel size [A]"; sxconst.help = ""; sxconst.register = "1.0"; sxconst.type = "float"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "ctfwin"; sxconst.label = "CTF window size [pixels]"; sxconst.help = "it should be slightly larger than particle box size"; sxconst.register = "512"; sxconst.type = "int"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "box"; sxconst.label = "Particle box size [pixels]" ; sxconst.help = ""; sxconst.register = "-1"; sxconst.type = "int"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "radius"; sxconst.label = "Protein particle radius [pixels]"; sxconst.help = ""; sxconst.register = "-1"; sxconst.type = "int"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "sym"; sxconst.label = "Point-group symmetry"; sxconst.help = "e.g. c1, c4, d5"; sxconst.register = "c1"; sxconst.type = "string"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "mass"; sxconst.label = "Protein molecular mass [kDa]"; sxconst.help = ""; sxconst.register = "-1.0"; sxconst.type = "float"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst + sxconst_set = SXconst_set(); + sxconst_set.name = "sxc_project"; + sxconst_set.label = "Project Settings"; + sxconst_set.short_info = "Set constant parameter values for this project. These constants will be used as default values of associated arguments and options in command settings. However, the project settings here are not required to run commands." + sxconst = SXconst(); + sxconst.key = "protein"; + sxconst.label = "Protein name"; + sxconst.help = "a valid string for file names on your OS."; + sxconst.register = "MY_PROTEIN"; + sxconst.type = "string"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "apix"; + sxconst.label = "Micrograph pixel size [A]"; + sxconst.help = ""; + sxconst.register = "1.0"; + sxconst.type = "float"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "ctfwin"; + sxconst.label = "CTF window size [pixels]"; + sxconst.help = "it should be slightly larger than particle box size"; + sxconst.register = "512"; + sxconst.type = "int"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "box"; + sxconst.label = "Particle box size [pixels]"; + sxconst.help = ""; + sxconst.register = "-1"; + sxconst.type = "int"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "radius"; + sxconst.label = "Protein particle radius [pixels]"; + sxconst.help = ""; + sxconst.register = "-1"; + sxconst.type = "int"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "sym"; + sxconst.label = "Point-group symmetry"; + sxconst.help = "e.g. c1, c4, d5"; + sxconst.register = "c1"; + sxconst.type = "string"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "mass"; + sxconst.label = "Protein molecular mass [kDa]"; + sxconst.help = ""; + sxconst.register = "-1.0"; + sxconst.type = "float"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst if helical: - sxconst = SXconst(); sxconst.key = "filament_width"; sxconst.label = "Filament width [pixels]"; sxconst.help = "Width of the filament in case of filamentous processing."; sxconst.register = "-1"; sxconst.type = "int"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst - sxconst = SXconst(); sxconst.key = "config"; sxconst.label = "Imaging configurations"; sxconst.help = "a free-style string for your record. please use it to describe the set of imaging configurations used in this project (e.g. types of microscope, detector, enegy filter, abbration corrector, phase plate, and etc."; sxconst.register = "MY_MICROSCOPE"; sxconst.type = "int"; sxconst_set.list.append(sxconst); sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "filament_width"; + sxconst.label = "Filament width [pixels]"; + sxconst.help = "Width of the filament in case of filamentous processing."; + sxconst.register = "-1"; + sxconst.type = "int"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst + sxconst = SXconst(); + sxconst.key = "config"; + sxconst.label = "Imaging configurations"; + sxconst.help = "a free-style string for your record. please use it to describe the set of imaging configurations used in this project (e.g. types of microscope, detector, enegy filter, abbration corrector, phase plate, and etc."; + sxconst.register = "MY_MICROSCOPE"; + sxconst.type = "int"; + sxconst_set.list.append(sxconst); + sxconst_set.dict[sxconst.key] = sxconst # Store the project constant parameter set as a class data member return sxconst_set def construct_sxcmd_category_list(self): sxcmd_category_list = [] - sxcmd_list = [] # Used only within this function + sxcmd_list = [] # Used only within this function sxcmd_category_dict = {} # Used only within this function # Actual configurations of all sx command categories and sx commands are inserted into the following section by wikiparser.py # as sxcmd_category_list and sxcmd_list # @@@@@ START_INSERTION @@@@@ - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_cter"; sxcmd_category.label = "CTF"; sxcmd_category.short_info = "CTF Estimation and CTF Assessment" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_cter"; + sxcmd_category.label = "CTF"; + sxcmd_category.short_info = "CTF Estimation and CTF Assessment" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_window"; sxcmd_category.label = "Particle Stack"; sxcmd_category.short_info = "Particle Coordinates and Particle Extraction" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_window"; + sxcmd_category.label = "Particle Stack"; + sxcmd_category.short_info = "Particle Coordinates and Particle Extraction" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_isac"; sxcmd_category.label = "2D Clustering"; sxcmd_category.short_info = "ISAC2 2D Clustering and Beautifier" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_isac"; + sxcmd_category.label = "2D Clustering"; + sxcmd_category.short_info = "ISAC2 2D Clustering and Beautifier" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_viper"; sxcmd_category.label = "Initial 3D Modeling"; sxcmd_category.short_info = "Initial 3D modeling with VIPER/RVIPER" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_viper"; + sxcmd_category.label = "Initial 3D Modeling"; + sxcmd_category.short_info = "Initial 3D modeling with VIPER/RVIPER" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_meridien"; sxcmd_category.label = "3D Refinement"; sxcmd_category.short_info = "MERIDIEN 3d Refinement and PostRefiner" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_meridien"; + sxcmd_category.label = "3D Refinement"; + sxcmd_category.short_info = "MERIDIEN 3d Refinement and PostRefiner" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_sort3d"; sxcmd_category.label = "3D Clustering"; sxcmd_category.short_info = "3D Variability and SROT3D_DEPTH 3D Clustering" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_sort3d"; + sxcmd_category.label = "3D Clustering"; + sxcmd_category.short_info = "3D Variability and SROT3D_DEPTH 3D Clustering" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_subtract"; sxcmd_category.label = "Signal Subtraction"; sxcmd_category.short_info = "Signal Subtraction" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_subtract"; + sxcmd_category.label = "Signal Subtraction"; + sxcmd_category.short_info = "Signal Subtraction" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_localres"; sxcmd_category.label = "Local Resolution"; sxcmd_category.short_info = "Local Resolution, and Local Filtering" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_localres"; + sxcmd_category.label = "Local Resolution"; + sxcmd_category.short_info = "Local Resolution, and Local Filtering" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_movie"; sxcmd_category.label = "Movie Micrograph"; sxcmd_category.short_info = "Micrograph Movie Alignemnt and Drift Assessment" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_movie"; + sxcmd_category.label = "Movie Micrograph"; + sxcmd_category.short_info = "Micrograph Movie Alignemnt and Drift Assessment" sxcmd_category_list.append(sxcmd_category) - sxcmd_category = SXcmd_category(); sxcmd_category.name = "sxc_utilities"; sxcmd_category.label = "Utilities"; sxcmd_category.short_info = "Miscellaneous Utlitity Commands" + sxcmd_category = SXcmd_category(); + sxcmd_category.name = "sxc_utilities"; + sxcmd_category.label = "Utilities"; + sxcmd_category.short_info = "Miscellaneous Utlitity Commands" sxcmd_category_list.append(sxcmd_category) - sxcmd = SXcmd(); sxcmd.name = "sp_cter"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF Estimation"; sxcmd.short_info = "Automated estimation of CTF parameters with error assessment, including Volta phase shift."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_image_path"; token.key_prefix = ""; token.label = "Input micrograph path pattern"; token.help = "Specify input micrographs path pattern with a wild card (*) for any of Micrograph Modes. Images in bdb format cannot be used as input micrographs. In an advanced option, a particle stack file path can also be given using --stack_mode. However, Stack Mode is not supported by sp_gui. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The CTF parameters (partres file), rotationally averaged power spectra (rotinf), and micrograph thumbnails (thumb files) will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Micrograph selection file"; token.help = "Specify path of a micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_one_ext"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrograph(s) or images in input particle stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "Cs"; token.key_prefix = "--"; token.label = "Microscope spherical aberration (Cs) [mm]"; token.help = "The spherical aberration (Cs) of microscope used for imaging. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ac"; token.key_prefix = "--"; token.label = "Amplitude contrast [%]"; token.help = "The amplitude contrast is in the range of 7% - 14%. The value depends on the thickness of the ice embedding the particles, among other factors. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "f_start"; token.key_prefix = "--"; token.label = "Lowest resolution [A]"; token.help = "Lowest resolution used in the CTF estimation. Determined automatically if not given. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "f_stop"; token.key_prefix = "--"; token.label = "Highest resolution [A]"; token.help = "Highest resolution used in the CTF estimation. Determined automatically if not given. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "wn"; token.key_prefix = "--"; token.label = "CTF window size [Pixels]"; token.help = "The window size should be slightly larger than particle box size. This will be ignored in Stack Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "512"; token.restore = [['512'], ['512']]; token.type = "ctfwin"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "kboot"; token.key_prefix = "--"; token.label = "Number of CTF estimates per micrograph"; token.help = "Used for error assessment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "16"; token.restore = [['16'], ['16']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overlap_x"; token.key_prefix = "--"; token.label = "X overlap [%]"; token.help = "Overlap between micrograph windows in the x direction. This will be ignored in Stack Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "50"; token.restore = [['50'], ['50']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overlap_y"; token.key_prefix = "--"; token.label = "Y overlap [%]"; token.help = "Overlap between micrograph windows in the y direction. This will be ignored in Stack Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "50"; token.restore = [['50'], ['50']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_x"; token.key_prefix = "--"; token.label = "Edge x [pixels]"; token.help = "Specifies micrograph exclusion margin in the x direction. This will be ignored in Stack Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_y"; token.key_prefix = "--"; token.label = "Edge y [pixels]"; token.help = "Specifies micrograph exclusion margin in the y direction. This will be ignored in Stack Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of inputs"; token.help = "Create a text file containing the list of inconsistent Micrograph ID entries (i.e. inconsist_mic_list_file.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "debug_mode"; token.key_prefix = "--"; token.label = "Enable debug mode"; token.help = "Print out debug information. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "vpp"; token.key_prefix = "--"; token.label = "Volta Phase Plate Dataset"; token.help = "UNDER DEVELOPMENT! Estimate phase shift. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "defocus_min"; token.key_prefix = "--"; token.label = "Minimum defocus search [um]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "0.3"; token.restore = [['0.3'], ['0.3']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "defocus_max"; token.key_prefix = "--"; token.label = "Maximum defocus search [um]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "9.0"; token.restore = [['9.0'], ['9.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "defocus_step"; token.key_prefix = "--"; token.label = "Defocus search step [um]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "phase_min"; token.key_prefix = "--"; token.label = "Minimum phase search [degrees]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "phase_max"; token.key_prefix = "--"; token.label = "Maximum phase search [degrees]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "175.0"; token.restore = [['175.0'], ['175.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "phase_step"; token.key_prefix = "--"; token.label = "Phase search step [degrees]"; token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "pap"; token.key_prefix = "--"; token.label = "Use PW spectrum"; token.help = "UNDER DEVELOPMENT! Use power spectrum for CTF parameter search instead of amplitude. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_gui_cter"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF Assessment"; sxcmd.short_info = "GUI tool to assess and sort micrographs according to their CTF parameters estimated by sp_cter."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "cter_ctf_file"; token.key_prefix = ""; token.label = "File containing CTF parameters"; token.help = "This file is produced by sp_cter and normally called partres.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_cter_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ctffind"; token.key_prefix = "--"; token.label = "ctffind"; token.help = "Use CTFFIND outputs (e.g., PWROT_DIR/*_avrot.txt, POWER2D_DIR/*.mrc). If using this option, you may need to specify the advanced parameters pwrot_dir and power2d_dir "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pwrot_dir"; token.key_prefix = "--"; token.label = "1D profile directory"; token.help = "Directory for 1D profiles "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "pwrot"; token.restore = [['pwrot'], ['pwrot']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "power2d_dir"; token.key_prefix = "--"; token.label = "2D power-spectrum directory"; token.help = "Directory for 2D power spectra "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "power2d"; token.restore = [['power2d'], ['power2d']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "micthumb_dir"; token.key_prefix = "--"; token.label = "2D power-spectrum directory"; token.help = "Directory for 2D power spectra "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "micthumb"; token.restore = [['micthumb'], ['micthumb']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "resample_micrographs"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Resample Micrographs"; sxcmd.short_info = "Resample micrographs in input directory specified by input micrograph pattern with user-specified ratio. This operation changes the image dimensitions and the pixel size. Mainly, it is designed to reduce the demensions and pixel size of micrographs taken with the super resolution mode of the K2 direct electron detector."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input micrograph path pattern"; token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. bdb files cannot be selected as input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resampling ratio"; token.help = "Specify ratio between new and original pixel size. Use a value between 0.0 and 1.0 (exclusive both ends). "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Micrograph selecting list"; token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be .txt. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of Micrograph ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info_TIMESTAMP.txt). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "organize_micrographs"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Organize Micrographs/Movies"; sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "source_micrograph_pattern"; token.key_prefix = ""; token.label = "Source micrograph/movies path pattern"; token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Micrograph/Movie selection file"; token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "select_mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "destination_directory"; token.key_prefix = ""; token.label = "Destination directory"; token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "reverse"; token.key_prefix = "--"; token.label = "Reverse operation"; token.help = "Move back micrographs/movies from the destination directory to the source directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "meridien"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Meridien)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "refinement_dir"; token.key_prefix = ""; token.label = "Meridien directory"; token.help = "Path to Meridien directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "manual"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Stack)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume_path"; token.key_prefix = ""; token.label = "Path to volume"; token.help = "Path to volume. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Params file"; token.help = "Path to params file "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk"; token.key_prefix = "--"; token.label = "Path to chunk file"; token.help = "Path to chunk file "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume2"; token.key_prefix = "--"; token.label = "Path to second volume"; token.help = "Path to second half volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "transphire"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "TranSPHIRE GUI"; sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_cter"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_cryolo_predict"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "crYOLO - predict"; sxcmd.short_info = "Prediction with crYOLO, a deep learning high accuracy particle picking procedure."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "cryolo_predict_path"; token.key_prefix = "--"; token.label = "crYOLO predict executable"; token.help = "Path to the cryolo_predict.py in your crYOLO environment "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "config_path"; token.key_prefix = ""; token.label = "Config file"; token.help = "Path of the crYOLO config file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_json"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_dir"; token.key_prefix = ""; token.label = "Image directory"; token.help = "Folder which contain all images. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "model_path"; token.key_prefix = ""; token.label = "Model path"; token.help = "Path to the trained model. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to write the box files. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "confidence_threshold"; token.key_prefix = "--"; token.label = "Confidence threshold [0-1]"; token.help = "Confidence threshold for picking. Particles with a confidence threshold lower than this value will be discarded. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.3"; token.restore = [['0.3'], ['0.3']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu"; token.key_prefix = "--"; token.label = "GPUs"; token.help = "List of GPUs to use, separated by commas if more than one. If no GPU is present, be sure to supply the non-GPU executable. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu_fraction"; token.key_prefix = "--"; token.label = "GPU memory fraction"; token.help = "Specify the fraction of memory per GPU used by crYOLO during prediction. Only values between 0.0 and 1.0 are allowed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "num_cpu"; token.key_prefix = "--"; token.label = "Number of CPUs"; token.help = "Number of CPUs used during prediction. By default it will use half of the available CPUs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "otf"; token.key_prefix = "--"; token.label = "On the fly filtering"; token.help = "If checked, the images are filtered on the fly and not saved to disk. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "min_distance"; token.key_prefix = "--"; token.label = "Minimum distance"; token.help = "Particles with a distance less than this value (in pixel) will be removed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_mode"; token.key_prefix = "--"; token.label = "Filament mode [Yes/No]"; token.help = "Check if you want to use the filament mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [Pixel]"; token.help = "Width of your filament in pixel. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "min_box_per_filament"; token.key_prefix = "--"; token.label = "Minimum number of boxes per filament"; token.help = "Specifies the minimum number of boxes per filament. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; token.default = "6"; token.restore = [['6'], ['6']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "box_distance"; token.key_prefix = "--"; token.label = "Box distance"; token.help = "Distance between two filament boxes in pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nosplit"; token.key_prefix = "--"; token.label = "Don't split curved filaments"; token.help = "If checked, the filament mode does not split curved filaments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nomerging"; token.key_prefix = "--"; token.label = "Don't merge filaments"; token.help = "If checked, the filament mode does not merge filaments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_window"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Particle Extraction"; sxcmd.short_info = "Window particles from micrographs using the particle coordinates."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input micrograph path pattern"; token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. bdb files cannot be selected as input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_coordinates_pattern"; token.key_prefix = ""; token.label = "Input coordinates path pattern"; token.help = "Specify path pattern of input coordinates files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_coords_any"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_ctf_params_source"; token.key_prefix = ""; token.label = "CTF parameters source"; token.help = "Specify the file produced by sp_cter and normally called partres.txt for cryo data. For negative staining data, enter pixel size [A/Pixels]. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_cter_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Micrograph selection file"; token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "coordinates_format"; token.key_prefix = "--"; token.label = "Coordinate file format"; token.help = "Allowed values are 'sphire', 'eman1', 'eman2', 'cryolo,'cryolo_helical_segmented' or 'spider'. The sphire, eman2, and spider formats use the particle center as coordinates. The eman1 format uses the lower left corner of the box as coordinates. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cryolo"; token.restore = [['cryolo', 'eman1', 'eman2', 'cryolo_helical_segmented'], ['cryolo', 'eman1', 'eman2', 'cryolo_helical_segmented']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "The x and y dimensions of square area to be windowed. The box size after resampling is assumed when resample_ratio < 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_invert"; token.key_prefix = "--"; token.label = "Invert image contrast"; token.help = "Indicate if image contrast should be inverted or not. Do not invert for negative staining data. By default, the image contrast will be inverted for cryo data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "limit_ctf"; token.key_prefix = "--"; token.label = "Use CTF limit filter"; token.help = "Frequencies where CTF oscillations cannot be properly modeled with the resampled pixel size will be discarded in the images with the appropriate low-pass filter. This flag has no effect when the CTER CTF File is not specified by the CTF paramters source argument. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "astigmatism_error"; token.key_prefix = "--"; token.label = "Astigmatism error limit [Degrees]"; token.help = "Set astigmatism to zero for all micrographs where the angular error computed by sp_cter is larger than the desired value. This parameter has no effect when the CTER CTF File is not specified by the CTF paramters source argument. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "360.0"; token.restore = [['360.0'], ['360.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Image size reduction factor (<1)"; token.help = "Use a value between 0.0 and 1.0 (excluding 0.0). The new pixel size will be automatically recalculated and stored in CTF paramers when resample_ratio < 1.0 is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of inputs"; token.help = "Create a text file containing the list of inconsistent Micrograph ID entries (i.e. inconsist_mic_list_file.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [Pixels]"; token.help = "Filament width for the creation of the rectangular mask. If -1 is selected, no mask will be applied. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2bdb"; sxcmd.subname = ""; sxcmd.mode = "makevstack"; sxcmd.subset_config = "fullset"; sxcmd.label = "Particle Stack"; sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "makevstack"; token.key_prefix = "--"; token.label = "Output virtual image stack"; token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_bdb_stack_pattern"; token.key_prefix = ""; token.label = "Input BDB image stack pattern"; token.help = "Specify file path pattern of stack subsets created in particle extraction using a wild card /'*/' (e.g. /'//sp_window_output_dir//*/'). The stack subsets are located in the sp_window output directory."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_cryolo_train"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "crYOLO - training"; sxcmd.short_info = "Training of crYOLO, a deep learning high accuracy particle picking procedure."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "cryolo_train_path"; token.key_prefix = "--"; token.label = "crYOLO train executeable"; token.help = "Path to the cryolo_train.py in your crYOLO environment "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_diameter"; token.key_prefix = ""; token.label = "Particle diameter [Pixel]"; token.help = "Particle diameter in pixels. This size will be used for as box size for picking. Should be as small as possible. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "training_dir"; token.key_prefix = ""; token.label = "Training image directory"; token.help = "Folder which contains all images. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "annot_dir"; token.key_prefix = ""; token.label = "Annotation directory"; token.help = "Box or star files used for training. Files should have the same name as the images, with the appropriate extension. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "architecture"; token.key_prefix = "--"; token.label = "Network architecture"; token.help = "Type of network that is trained. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "PhosaurusNet"; token.restore = [['PhosaurusNet'], ['PhosaurusNet']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_size"; token.key_prefix = "--"; token.label = "Input image dimension [Pixel]"; token.help = "Dimension of the image used as input by the network. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1024"; token.restore = [['1024'], ['1024']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "num_patches"; token.key_prefix = "--"; token.label = "Number of patches"; token.help = "The number of patches (e.g 2x2) the image is divided into and classified separately. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overlap_patches"; token.key_prefix = "--"; token.label = "Patch overlap [Pixel]"; token.help = "The amount of overlap the patches will overlap "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "train_times"; token.key_prefix = "--"; token.label = "Repeat images"; token.help = "How often a images is augmented and repeated in one epoch. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10"; token.restore = [['10'], ['10']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pretrained_weights_name"; token.key_prefix = "--"; token.label = "Pretrained weights name"; token.help = "Name of the pretrained model "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cryolo_model.h5"; token.restore = [['cryolo_model.h5'], ['cryolo_model.h5']]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "saved_weights_name"; token.key_prefix = "--"; token.label = "Saved weights name"; token.help = "Name of the model to save "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cryolo_model.h5"; token.restore = [['cryolo_model.h5'], ['cryolo_model.h5']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "batch_size"; token.key_prefix = "--"; token.label = "Batch size"; token.help = "How many patches are processed in parallel. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fine_tune"; token.key_prefix = "--"; token.label = "Fine tune mode"; token.help = "Set it to true if you only want to use the fine tune mode. Don't forget to choose an appropriate pretrained model (like the general model) that is refined. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "warmup"; token.key_prefix = "--"; token.label = "Warm up epochs"; token.help = "Number of warmup epochs. If you fine tune a model, set it to zero. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "learning_rate"; token.key_prefix = "--"; token.label = "Learning rate"; token.help = "Learning rate used during training. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0001"; token.restore = [['0.0001'], ['0.0001']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "np_epoch"; token.key_prefix = "--"; token.label = "Number of epochs"; token.help = "Maximum number of epochs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "object_scale"; token.key_prefix = "--"; token.label = "Object loss scale"; token.help = "Loss scale for object. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "no_object_scale"; token.key_prefix = "--"; token.label = "Background loss scale"; token.help = "Loss scale for background. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "coord_scale"; token.key_prefix = "--"; token.label = "Coordinates loss scale"; token.help = "Loss scale for coordinates. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "valid_image_dir"; token.key_prefix = "--"; token.label = "Path to validation images"; token.help = "Images used "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "valid_annot_dir"; token.key_prefix = "--"; token.label = "Path to validation annotations"; token.help = "Path to the validation box files "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skiplowpass"; token.key_prefix = "--"; token.label = "Skip low pass filtering"; token.help = "Set it to true if you want to skip the low pass filter "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cutoff"; token.key_prefix = "--"; token.label = "Low pass cutoff"; token.help = "Cut off for low pass filter. Should be between 0 and 0.5. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skiplowpass', 'False', 'False']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "filtered_dir"; token.key_prefix = "--"; token.label = "Filtering directory"; token.help = "Path to write filtered images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cryolo_filtered_micrographs"; token.restore = [['cryolo_filtered_micrographs'], ['cryolo_filtered_micrographs']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "usejanni"; token.key_prefix = "--"; token.label = "Use JANNI for denoising"; token.help = "Set it to true if you want to use JANNI for denoising. Low pass filtering has to be skipped. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "janni_model"; token.key_prefix = "--"; token.label = "JANNI model"; token.help = "Path to JANNI model "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "janni_overlap"; token.key_prefix = "--"; token.label = "JANNI patch overlap"; token.help = "Overlap of patches in pixel "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; token.default = "24"; token.restore = [['24'], ['24']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "janni_batches"; token.key_prefix = "--"; token.label = "JANNI number batches"; token.help = "Number of batches when using JANNI "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "gpu"; token.key_prefix = "--"; token.label = "GPUs"; token.help = "List of GPUs to use, separated by commas. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu_fraction"; token.key_prefix = "--"; token.label = "GPU memory fraction"; token.help = "Specify the fraction of memory per GPU used by crYOLO during training. Only values between 0.0 and 1.0 are allowed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "num_cpu"; token.key_prefix = "--"; token.label = "Number of CPUs"; token.help = "Number of CPUs used during training. By default it will use half of the available CPUs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "restacking"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Restacking"; sxcmd.short_info = "Generate all necessary information to restack the input stack (i.e., particle image ID list, CTF parameters list, projection parameters list) while applying micrograph selection list. Optionally, the command can directly output the virtual stack. In addition, this command can be used to generate all parameters files for reboxing (i.e. original/centered particle coordinates list files, CTF parameters list, original/centered projection parameters list as well as micrograph selection file). Optionally, user can provided a 3D shift to recenter the projection parameters and so the particle coordinates."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_bdb_stack_path"; token.key_prefix = ""; token.label = "Input bdb image stack"; token.help = "Specify the input bdb image stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Micrograph/Movie selection file"; token.help = "Specify path to text file containing a list of selected micrograph/movie names or paths. The particles associated with the micrographs/movies in this list will be processed. The file extension must be .txt. The directory path of each entry will be ignored if there is any. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "save_vstack"; token.key_prefix = "--"; token.label = "Save virtual stack"; token.help = "Use this option to save the virtual stack. By default, the virtual stack will not be generated. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sv_vstack_basename"; token.key_prefix = "--"; token.label = "Virtual stack basename"; token.help = "Specify the basename of output virtual stack file. It cannot be empty string or only white spaces. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['save_vstack', 'True', 'False']]; token.default = "vstack"; token.restore = [['vstack'], ['vstack']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('save_vstack', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "reboxing"; token.key_prefix = "--"; token.label = "Generate reboxing information"; token.help = "Prepare reboxing by extracting coordinates from the input stack headers, then center them according to projection parameters in the header and user-provided 3D shift. If the headers do not contain projection parameters, the program assumes the projection parameters are all zeros (null alignment). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rb_box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "For --reboxing option, specify the x and y dimensions of square area to be windowed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['reboxing', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('reboxing', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_rewindow"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Particle Reextraction"; sxcmd.short_info = "Rewindow particles from micrographs using the information stored in rebox files."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input micrograph path pattern"; token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and rebox file. bdb files cannot be selected as input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_rebox_pattern"; token.key_prefix = ""; token.label = "Input rebox path pattern"; token.help = "Specify path pattern of input rebox files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated input micrograph. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_rebox_rbx"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Micrograph selection file"; token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "The x and y dimensions of square area to be windowed. The box size after resampling is assumed when mic_resample_ratio < 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_invert"; token.key_prefix = "--"; token.label = "Invert image contrast"; token.help = "Indicate if image contrast should be inverted or not. Do not invert for negative staining data. By default, the image contrast will be inverted for cryo data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mic_resample_ratio"; token.key_prefix = "--"; token.label = "Image size reduction factor (<1)"; token.help = "Use a value between 0.0 and 1.0 (excluding 0.0). The new pixel size will be automatically recalculated and stored in CTF paramers when mic_resample_ratio < 1.0 is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "swap_ctf_params"; token.key_prefix = "--"; token.label = "Swap CTF parameters"; token.help = "Swaps CTF parameters by setting the CTF parameters in the specified CTER partres file while ignoring the CTF parameters in the input rebox parameters file. Typically, specify the file produced by sp_cter and normally called partres.txt. Alternatively, enter pixel size [A/Pixels] to simulate ideal CTF. By default, the program uses the CTF parameters in the input rebox parameters file. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_cter_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of Micrograph ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info_TIMESTAMP.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2boxer_old"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Particle Coordinates"; sxcmd.short_info = "Generate files containing particle coordinates for all input micrographs by picking particles manual and/or automatically."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_micrograph_list"; token.key_prefix = ""; token.label = "Input micrographs"; token.help = "Wild cards (e.g. *) can be used to specify a list of micrographs. Not recommended if their number is very large. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_one_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "boxsize"; token.key_prefix = "--"; token.label = "Box size [Pixels]"; token.help = "Box size for extraction of particle images. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert"; token.key_prefix = "--"; token.label = "Invert contrast"; token.help = "Invert contrast of micrographs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Verbose level. Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2boxer"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Particle Coordinates (NEW)"; sxcmd.short_info = "Generate files containing particle coordinates for all input micrographs by picking particles manual and/or automatically."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_micrograph_list"; token.key_prefix = ""; token.label = "Input micrograph list"; token.help = "Wild cards (e.g. *) can be used to specify a list of micrographs. Not recommended if their number is very large. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_one_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Angstroms per pixel for all images. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "boxsize"; token.key_prefix = "--"; token.label = "Box size [Pixels]"; token.help = "Box size in pixels. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ptclsize"; token.key_prefix = "--"; token.label = "Particle diameter [Pixels]"; token.help = "Longest axis of particle in pixels (diameter, not radius). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert"; token.key_prefix = "--"; token.label = "Invert input contrast"; token.help = "Preferably, particles should be bright on a dark background. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "no_ctf"; token.key_prefix = "--"; token.label = "Disable CTF estimation"; token.help = "Disable CTF estimation. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gui"; token.key_prefix = "--"; token.label = "Interactive GUI mode"; token.help = "Use interactive GUI mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "write_dbbox"; token.key_prefix = "--"; token.label = "Export EMAN1 box files"; token.help = "Export EMAN1 box files (.box extension). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "unboxedonly"; token.key_prefix = "--"; token.label = "Include only unboxed micrographs"; token.help = "Only include image files without existing box locations. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "write_ptcls"; token.key_prefix = "--"; token.label = "Save selected particle"; token.help = "Extract selected particles from micrographs and write to disk. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allmicrographs"; token.key_prefix = "--"; token.label = "Include all micrographs in a directory"; token.help = "Add all images from micrographs folder. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "suffix"; token.key_prefix = "--"; token.label = "Micrograph suffix"; token.help = "Suffix of the micrographs used for particle picking (i.e. suffix=goodali will use micrographs end with _goodali.hdf). It is only useful when --allmicrographs option is True. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['allmicrographs', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('allmicrographs', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cs"; token.key_prefix = "--"; token.label = "Microscope spherical aberration (Cs) [mm]"; token.help = "The spherical aberration (Cs) of microscope used for imaging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ac"; token.key_prefix = "--"; token.label = "Amplitude contrast [%]"; token.help = "The typical amplitude contrast is in the range of 7% - 14%. The value mainly depends on the thickness of the ice embedding the particles. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "autopick"; token.key_prefix = "--"; token.label = "Perform automatic particle picking"; token.help = "Provide mode and parameter string (eg - auto_local:threshold=5.5). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "threads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "Number of threads to run in parallel on a single computer. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "organize_micrographs"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Organize Micrographs/Movies"; sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "source_micrograph_pattern"; token.key_prefix = ""; token.label = "Source micrograph/movies path pattern"; token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Micrograph/Movie selection file"; token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "select_mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "destination_directory"; token.key_prefix = ""; token.label = "Destination directory"; token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "reverse"; token.key_prefix = "--"; token.label = "Reverse operation"; token.help = "Move back micrographs/movies from the destination directory to the source directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_cryolo_boxmanager"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "crYOLO - boxmanager"; sxcmd.short_info = "Displays boxfiles on images. Allows creation of new training data for crYOLO."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "cryolo_bm_path"; token.key_prefix = "--"; token.label = "crYOLO boxmanager executable"; token.help = "Path to crYOLO boxmanager executable "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_dir"; token.key_prefix = "--"; token.label = "Input image directory"; token.help = "Path to input images "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_dir"; token.key_prefix = "--"; token.label = "Annotation directory"; token.help = "Path to annotation data like .box or .star files "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_window"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_isac2"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "ISAC2 - 2D Clustering"; sxcmd.short_info = "Iterative Stable Alignment and Clustering (ISAC) of a 2D image stack."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack_file"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Images must to be square (nx=ny). The stack can be either in .bdb or in .hdf format. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "General ISAC output directory to store all results. If the directory already exists ISAC will only run in continuation mode (see advanced parameter restart). "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Radius of the particle in pixels. ISAC cannot offer a default here since the value will depend on the particle im question. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp"; token.key_prefix = "--"; token.label = "Images per class"; token.help = "Ideally the number of images per class. In practice this value determines the number of classes K = N / img_per_grp, where N is the total number of images in the input stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "200"; token.restore = [['200'], ['200']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "CTF"; token.key_prefix = "--"; token.label = "CTF phase flipping"; token.help = "Use for cryo datasets. If set to True the data will be phase-flipped using CTF information included in the image headers. Cannot be used together with the VPP option. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['VPP', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('VPP', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "VPP"; token.key_prefix = "--"; token.label = "Phase Plate data"; token.help = "Use this option if the dataset is taken with a phase plate. Cannot be used together with the CTF option. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['CTF', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('CTF', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Translation search range [Pixels]"; token.help = "The translational search range. Change with care; higher values will incur significantly higher processing costs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "thld_err"; token.key_prefix = "--"; token.label = "Pixel error threshold [Pixels]"; token.help = "Used as a threshold value when checking cluster stability. The pixel error is defined as the root mean square of distances between corresponding pixels from set of found transformations and their average transformation; it depends linearly on square of radius (parameter ou). units - pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.7"; token.restore = [['0.7'], ['0.7']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_radius"; token.key_prefix = "--"; token.label = "Target particle radius [Pixels]"; token.help = "Particle radius used by ISAC2 to process the data. All particle images will be re-scaled to match their particle radius with this radius. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_nx"; token.key_prefix = "--"; token.label = "Target particle image size [Pixels]"; token.help = "Image size used by ISAC2 to process the data. particle images will first be resized according to target particle radius (see above) and then cropped or padded to achieve the target image size. When xr > 0, the final image size for ISAC2 processing is target_nx + xr - 1 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "76"; token.restore = [['76'], ['76']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ir"; token.key_prefix = "--"; token.label = "Inner ring [Pixels]"; token.help = "Radius of the inner-most ring when resampling images to polar coordinates. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rs"; token.key_prefix = "--"; token.label = "Ring step [Pixels]"; token.help = "Radius step size when resampling images to polar coordinates. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step [Pixels]"; token.help = "Translational search step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit"; token.key_prefix = "--"; token.label = "Reference-free alignment iterations"; token.help = "The number of iterations for reference-free alignments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "30"; token.restore = [['30'], ['30']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center_method"; token.key_prefix = "--"; token.label = "Centering method"; token.help = "Method to center global 2D average during the initial prealignment of the data (0: no centering; -1: average shift method; please see function center_2D in sp_utilities.py for methods 1-7). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dst"; token.key_prefix = "--"; token.label = "Discrete angle used for within-group alignment"; token.help = "Discrete angle used for within-group alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "90.0"; token.restore = [['90.0'], ['90.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FL"; token.key_prefix = "--"; token.label = "Lowest filter frequency [1/Pixel]"; token.help = "Lowest frequency used for the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.2"; token.restore = [['0.2'], ['0.2']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FH"; token.key_prefix = "--"; token.label = "Highest filter frequency [1/Pixel]"; token.help = "Highest frequency used for the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.45"; token.restore = [['0.45'], ['0.45']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FF"; token.key_prefix = "--"; token.label = "Tangent filter fall-off"; token.help = "The fall-off of the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.2"; token.restore = [['0.2'], ['0.2']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "init_iter"; token.key_prefix = "--"; token.label = "Maximum generations"; token.help = "Maximum number of generation iterations performed for a given subset. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "7"; token.restore = [['7'], ['7']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "iter_reali"; token.key_prefix = "--"; token.label = "SAC stability check interval"; token.help = "Defines every how many iterations the SAC stability checking is performed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stab_ali"; token.key_prefix = "--"; token.label = "Number of alignments for stability check"; token.help = "The number of alignment runs when checking stability. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "minimum_grp_size"; token.key_prefix = "--"; token.label = "Minimum size of reproducible classes"; token.help = "Minimum size of reproducible classes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "60"; token.restore = [['60'], ['60']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rand_seed"; token.key_prefix = "--"; token.label = "Seed"; token.help = "Random seed set before calculations. Useful for testing purposes. By default, ISAC2 sets a random seed number. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_prealignment"; token.key_prefix = "--"; token.label = "Do pre-alignment"; token.help = "Indicate if pre-alignment should be used or not. Do not use pre-alignment if images are already centered. The 2dalignment directory will still be generated but the parameters will be zero. By default, do pre-alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "restart"; token.key_prefix = "--"; token.label = "Restart run"; token.help = "0: Restart ISAC2 after the last completed main iteration (i.e. the directory must contain finished file); k: Restart ISAC2 after k-th main iteration, it has to be completed (i.e. the directory must contain finished file), and higer iterations will be removed; Default: Do not restart. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_ordering"; token.key_prefix = "--"; token.label = "Skip ordered class averages"; token.help = "Skip the creation of the ordered class averages. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [Pixels]"; token.help = "When this is set to a non-default value, ISAC assumes helical data, in which case particle images will be subjected to rectangular masking of the given this value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_mask_ignore"; token.key_prefix = "--"; token.label = "Ignore filament masking (filament use only)"; token.help = "ONLY RELEVANT IF parameter filament_width is set to a non-default value. When processing helical particle images rectangular masking is used (A) to normalize and (B) to mask the actual particle images. The latter can be disabled by setting this flag to True. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_isac2_gpu"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "GPU ISAC - 2D Clustering"; sxcmd.short_info = "Iterative Stable Alignment and Clustering (ISAC) of a 2D image stack, using the GPU."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack_file"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Images must to be square (nx=ny). The stack can be either in .bdb or in .hdf format. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "General ISAC output directory to store all results. If the directory already exists ISAC will only run in continuation mode (see advanced parameter restart). "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Radius of the particle in pixels. ISAC cannot offer a default here since the value will depend on the particle im question. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp"; token.key_prefix = "--"; token.label = "Images per class"; token.help = "also defines number of classes K=(total number of images)/img_per_grp. If not specified, the value will be set to yield 200 classes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "CTF"; token.key_prefix = "--"; token.label = "CTF phase flipping"; token.help = "Use for cryo datasets. If set to True the data will be phase-flipped using CTF information included in the image headers. Cannot be used together with the VPP option. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['VPP', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('VPP', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "VPP"; token.key_prefix = "--"; token.label = "Phase Plate data"; token.help = "Use this option if the dataset is taken with a phase plate. Cannot be used together with the CTF option. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['CTF', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('CTF', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "gpu_devices"; token.key_prefix = "--"; token.label = "GPU devices"; token.help = "Specify the GPUs to be used (e.g. --gpu_devices=0, or --gpu_devices=0,1 for one or two GPUs, respectively). Using nvidia-smi in the terminal will print out what GPUs are available. For a more detailed printout you can also use --gpu_info here in ISAC. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu_memory_use"; token.key_prefix = "--"; token.label = "GPU memory use"; token.help = "Specify how much memory on the chosen GPUs ISAC is allowed to use. A value of 0.9 results in using 90% of the available memory (this is the default; higher percentages should be used with caution). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.9"; token.restore = [['0.9'], ['0.9']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Translation search range [Pixels]"; token.help = "The translational search range. Change with care; higher values will incur significantly higher processing costs. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "thld_err"; token.key_prefix = "--"; token.label = "Pixel error threshold [Pixels]"; token.help = "Used as a threshold value when checking cluster stability. The pixel error is defined as the root mean square of distances between corresponding pixels from set of found transformations and their average transformation; it depends linearly on square of radius (parameter ou). units - pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.7"; token.restore = [['0.7'], ['0.7']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_radius"; token.key_prefix = "--"; token.label = "Target particle radius [Pixels]"; token.help = "Particle radius used by ISAC2 to process the data. All particle images will be re-scaled to match their particle radius with this radius. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_nx"; token.key_prefix = "--"; token.label = "Target particle image size [Pixels]"; token.help = "Image size used by ISAC2 to process the data. particle images will first be resized according to target particle radius (see above) and then cropped or padded to achieve the target image size. When xr > 0, the final image size for ISAC2 processing is target_nx + xr - 1 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "76"; token.restore = [['76'], ['76']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ir"; token.key_prefix = "--"; token.label = "Inner ring [Pixels]"; token.help = "Radius of the inner-most ring when resampling images to polar coordinates. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rs"; token.key_prefix = "--"; token.label = "Ring step [Pixels]"; token.help = "Radius step size when resampling images to polar coordinates. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step [Pixels]"; token.help = "Translational search step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit"; token.key_prefix = "--"; token.label = "Reference-free alignment iterations"; token.help = "The number of iterations for reference-free alignments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "30"; token.restore = [['30'], ['30']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center_method"; token.key_prefix = "--"; token.label = "Centering method"; token.help = "Method for centering of global 2D averages during the initial prealignment of the data (0 : average centering; -1 : average shift method; please see center_2D in sp_utilities.py for methods 1-7). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dst"; token.key_prefix = "--"; token.label = "Discrete angle used for within-group alignment"; token.help = "Discrete angle used for within-group alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "90.0"; token.restore = [['90.0'], ['90.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FL"; token.key_prefix = "--"; token.label = "Lowest filter frequency [1/Pixel]"; token.help = "Lowest frequency used for the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.2"; token.restore = [['0.2'], ['0.2']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FH"; token.key_prefix = "--"; token.label = "Highest filter frequency [1/Pixel]"; token.help = "Highest frequency used for the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.45"; token.restore = [['0.45'], ['0.45']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "FF"; token.key_prefix = "--"; token.label = "Tangent filter fall-off"; token.help = "The fall-off of the tangent filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.2"; token.restore = [['0.2'], ['0.2']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "init_iter"; token.key_prefix = "--"; token.label = "Maximum generations"; token.help = "Maximum number of generation iterations performed for a given subset. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "7"; token.restore = [['7'], ['7']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "main_iter_limit"; token.key_prefix = "--"; token.label = "Main iteration limit"; token.help = "If set to a positive value N, ISAC execution is halted after N main iterations. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "iter_reali"; token.key_prefix = "--"; token.label = "SAC stability check interval"; token.help = "Defines every how many iterations the SAC stability checking is performed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stab_ali"; token.key_prefix = "--"; token.label = "Number of alignments for stability check"; token.help = "The number of alignment runs when checking stability. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "minimum_grp_size"; token.key_prefix = "--"; token.label = "Minimum group size"; token.help = "Minimum size of reproducible classes. If not specified, this value will be set to 60% of the 'img_per_group' value (see above). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rand_seed"; token.key_prefix = "--"; token.label = "Seed"; token.help = "Random seed set before calculations. Useful for testing purposes. By default, ISAC2 sets a random seed number. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_prealignment"; token.key_prefix = "--"; token.label = "Do pre-alignment"; token.help = "Indicate if pre-alignment should be used or not. Do not use pre-alignment if images are already centered. The 2dalignment directory will still be generated but the parameters will be zero. By default, do pre-alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "restart"; token.key_prefix = "--"; token.label = "Restart run"; token.help = "0: Restart ISAC2 after the last completed main iteration (i.e. the directory must contain finished file); k: Restart ISAC2 after k-th main iteration, it has to be completed (i.e. the directory must contain finished file), and higer iterations will be removed; Default: Do not restart. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_ordering"; token.key_prefix = "--"; token.label = "Skip ordered class averages"; token.help = "Skip the creation of the ordered class averages. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [Pixels]"; token.help = "When this is set to a non-default value, ISAC assumes helical data, in which case particle images will be subjected to rectangular masking of the given this value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_mask_ignore"; token.key_prefix = "--"; token.label = "Ignore filament masking (filament use only)"; token.help = "ONLY RELEVANT IF parameter filament_width is set to a non-default value. When processing helical particle images rectangular masking is used (A) to normalize and (B) to mask the actual particle images. The latter can be disabled by setting this flag to True. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu_info"; token.key_prefix = "--"; token.label = "GPU info"; token.help = "Print detailed information about the selected GPUs, including the class limit which is relevant when using the --gpu_class_limit parameter. Use --gpu_devices to specify what GPUs you want to know about. NOTE: ISAC will stop after printing this information, so don't use this parameter if you intend to actually process any data. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_compute_isac_avg"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Beautifier"; sxcmd.short_info = "Perform local 2D alignment of ISAC2 2D clustering results using the original pixel size and full CTF correction."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = "--"; token.label = "Original image stack"; token.help = "Data stack that used for the associated ISAC2 run. The particle images in this stack are used to create the full-sized class averages. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "isac_dir"; token.key_prefix = "--"; token.label = "ISAC2 run directory"; token.help = "Path to the output directory of the associated ISAC2 run. This is the input directory for this command. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "This automatically-created output directory will contain results. By default, the program uses sharpen_DATA_AND_TIME for the name. If this is the same as ISAC2 run directory, the program automatically creates sharpen subdirectory under the ISAC2 run directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of particle images in input particle stack for the associated ISAC2 run. Use 1.0 in case of negative stain data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "There is no default radius. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "noctf"; token.key_prefix = "--"; token.label = "CTF correction"; token.help = "Indicate if full CTF correction should be applied or not. Always use the CTF correction for cryo data, but not for negative stained data. By default, do full CTF correction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "local_alignment"; token.key_prefix = "--"; token.label = "Local alignment"; token.help = "Indicate if local alignment should be applied or not. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = True; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [1/Pixel]"; token.help = "Cutoff frequency of low-pass filter. =-1.0, do not apply the low-pass filter; =0.0, apply low pass filter to initial ISAC2 resolution; =1.0, to resolution after local alignment; else use user-provided cutoff in absolute frequency (>0.0 and <=0.45). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "abs_freq"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pw_adjustment"; token.key_prefix = "--"; token.label = "Power spectrum adjustment method"; token.help = "Specify the method for the power spectrum (PWS) adjustment of 2-D averages to enhance averages. ='analytical_model' adjusts PWS to an analytic model; ='bfactor' adjusts PWS using B-factor; ='FILE_PATH' adjusts PWS to rotationally averaged 1D power spectrum stored in the text file; ='no_adjustment' skips adjustment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "analytical_model"; token.restore = [['analytical_model'], ['analytical_model']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_start"; token.key_prefix = "--"; token.label = "Lower bound for B-factor estimation [A]"; token.help = "Lower resolution bound of power spectrum for B-factor estimation. Specific to adjust to B-factor method. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "45.0"; token.restore = [['45.0'], ['45.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "Bfactor"; token.key_prefix = "--"; token.label = "Use ad-hoc B-factor [A^2]"; token.help = "Skip the automatic estimation and use user-provided ad-hoc B-factor (e.g. 25.0[A^2]) for the enhancement. By default, the program automatically estimates B-factor. Specific to adjust to B-factor method. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Local search range [Pixels]"; token.help = "Translational search range for local alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Local search step [Pixels]"; token.help = "Translational search step for local alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "fh"; token.key_prefix = "--"; token.label = "High frequency search limit [1/Pixel]"; token.help = "High frequency search limit in absolute frequency for local alignment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "abs_freq"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "maxit"; token.key_prefix = "--"; token.label = "Local alignment iterations"; token.help = "The number of iterations for local aligment. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "navg"; token.key_prefix = "--"; token.label = "Number of averages"; token.help = "The number of averages to be process, starting from the first image. By default, uses all ISAC2 average images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1000000"; token.restore = [['1000000'], ['1000000']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "isac_substack"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "ISAC2 Stack Subset"; sxcmd.short_info = "Create a virtual subset stack consisting of particles acounted for by ISAC2 by retrieving particle numbers associated with the ISAC2 or Beautifier class averages. The command also saves a selection file containing the retrieved original image numbers and 2D alignment parameters. In addition, it stores the 2D alignment parameters to the stack header."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_bdb_stack_path"; token.key_prefix = ""; token.label = "Input bdb image stack"; token.help = "Specify the same bdb image stack used for the associated ISAC2 run. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "ISAC2 or Beautifier run output directory"; token.help = "Specify output directory of an ISAC2 or Beautifier run as an input to this command. From this directory, the program extracts the shrink ratio and 2D alignment parameters of the ISAC2 run or local 2D alignment parameters of the Beautifier run. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "isac_class_avgs_path"; token.key_prefix = "--"; token.label = "ISAC2 or Beautifier class averages path"; token.help = "Specify path to a file containg ISAC2 or Beautifier class averages. The class averages can be fullset or selected subset, as long as they are associated with the input bdb image stack and contain class member information stored in the headers. By default, the program uses the same default name of ordered class averages in ISAC2 or Beautifier (i.e. ordered_class_averages.hdf). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "substack_basename"; token.key_prefix = "--"; token.label = "Stack subset basename"; token.help = "Specify the basename of ISAC2 stack subset file. It cannot be empty string or only white spaces. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "isac_substack"; token.restore = [['isac_substack'], ['isac_substack']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2bdb"; sxcmd.subname = ""; sxcmd.mode = "makevstack"; sxcmd.subset_config = ""; sxcmd.label = "Create Virtual Stack"; sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "makevstack"; token.key_prefix = "--"; token.label = "Output virtual image stack"; token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_bdb_stack_file"; token.key_prefix = ""; token.label = "Input BDB image stack"; token.help = "Specify path to input BDB stack file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Image selection file"; token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual bdb image stack from an existed stack or virtual stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) - token = SXcmd_token(); token.key_base = "exlist"; token.key_prefix = "--"; token.label = "Image exclusion file"; token.help = "Input exclusion text file containing a list of excluded image IDs (or indexes of the data subset) to create a new virtual bdb image stacks from an existed stack or virtual stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['step', '0,1', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Processes only subset"; token.help = "Specify <init>,<step>[,<max>]. Process only a subset of the input data. For example, 0,2 would process only the even numbered particles. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['exlist', 'none', 'False']]; token.default = "0,1"; token.restore = [['0,1'], ['0,1']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_eval_isac"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Evaluate ISAC classes"; sxcmd.short_info = "Separates stacks of particle images into stacks for each class."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_class_avgs"; token.key_prefix = ""; token.label = "Input class averages"; token.help = "Set of 2D class averages, with particle-membership information in header. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particles"; token.key_prefix = "--"; token.label = "Input particle stack"; token.help = "Required if particles will be processed (i.e., everything except simple class seperation or bandpass filtration). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "align_isac_dir"; token.key_prefix = "--"; token.label = "ISAC/Beautifier direrctory"; token.help = "ISAC or beautifier directory, from which alignment parameters will be applied. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filtrad"; token.key_prefix = "--"; token.label = "Low-pass filter radius"; token.help = "Low-pass filter radius. If pixel size is provided, then units will be Angstroms. If pixel size is not is not specified, program will assume units of absolute frequency (0..0.5). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size"; token.help = "Pixel size, in Angstroms. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shrink"; token.key_prefix = "--"; token.label = "Downsampling factor"; token.help = "Factor by which images will be downsampled. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "ctf"; token.key_prefix = "--"; token.label = "CTF-correction mode"; token.help = "Allowed options are 'flip' (phase-flipping) and 'wiener' (phase and amplitude, like with beautifier). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = "None"; token.restore = [['None', 'flip', 'wiener'], ['None', 'flip', 'wiener']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "chains_radius"; token.key_prefix = "--"; token.label = "Chains radius"; token.help = "Alignment radius for generating ordered class averages internally. Units are pixels, on the scale of the input class averages. In other words, for ISAC averages, this value will typically be 29. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "nvec"; token.key_prefix = "--"; token.label = "Number of eigenimages"; token.help = "Number of eigenimages to compute using principal component analysis. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "pca_radius"; token.key_prefix = "--"; token.label = "PCA radius"; token.help = "Radius for principal component analysis (PCA). Only pixels within this radius will be examined using PCA. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "mask_binary"; token.key_prefix = "--"; token.label = "Binary mask file"; token.help = "A binary mask file to use for principal component analysis. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "mask_drawn"; token.key_prefix = "--"; token.label = "Drawn mask file"; token.help = "A drawn mask means that, using e2display.py or a similar program, a mask was drawn on top of a class average. The mask will be binarized according to the maximum of the class average, and that binary mask will be used for PCA. When running sp_eval_isac.py, the screen output will report the maximum pixel value among the class averages. Use a value exceeding that value for the pen intensity when drawing the mask using e2display.py. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "bandpass_radius"; token.key_prefix = "--"; token.label = "Bandpass radius"; token.help = "Applies a bandpass filter to class averages. Bandpass radius assumed to be in units of Angstroms if pixel size is provided. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'False']) - token = SXcmd_token(); token.key_base = "write_centered"; token.key_prefix = "--"; token.label = "Apply centering"; token.help = "Applies centering parameters from sp_center_2d3d.py. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "applyparams"; token.key_prefix = "--"; token.label = "Centering options"; token.help = "Allowed centering options are 'combined' (shifts and rotation, both floating point) and 'intshifts' (integer shifts only, to avoid interpolation). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['write_centered', 'True', 'False']]; token.default = "combined"; token.restore = [['combined', 'intshifts'], ['combined', 'intshifts']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('write_centered', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Debug centering"; token.help = "For use with centering option 'intshifts', to make sure that correct shifts are applied, rotation is applied, and averages are computed. If this flag is not activated, no averages will be generated. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['applyparams', 'intshifts', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('applyparams', []).append([token.key_base, 'intshifts', 'False']) - token = SXcmd_token(); token.key_base = "bandpass_width"; token.key_prefix = "--"; token.label = "Bandpass width"; token.help = "Width of bandpass filter, in units of absolute frequency (i.e., 0..0.5). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['bandpass_radius', 'None', 'True']]; token.default = "0.03"; token.restore = [['0.03'], ['0.03']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('bandpass_radius', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity"; token.help = "Controls the amount of information written to the screen, ranging from 0..6. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_compare2d"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compare 2D images"; sxcmd.short_info = "Find best match between two sets of 2D images."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "image_stack_1"; token.key_prefix = ""; token.label = "Input stack #1"; token.help = "To each imagine in this stack, all of the images in the second input stack will be compared. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "image_stack_2"; token.key_prefix = ""; token.label = "Input stack #2"; token.help = "Each image from this stack will be aligned to each image from the first input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where output files will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outterradius"; token.key_prefix = "--"; token.label = "Outer radius"; token.help = "Outer radius in pixels. If not specified, the maximum allowed from the image dimension and maximum shift will be used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "normalize"; token.key_prefix = "--"; token.label = "Normalization mode"; token.help = "Methods for displaying the images from the two inputs stacks. If both comes from the same source, uses 'None'. Other options: 'minmax' (sets the minimum and maximum for each image to constants), 'rops' (sets 1D rotational power spectra equal to each other), and 'sigmaone' (sets the average to 0 and sigma to 1). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None', 'minmax', 'rops', 'sigmaone'], ['None', 'minmax', 'rops', 'sigmaone']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxshift"; token.key_prefix = "--"; token.label = "Maximum shift"; token.help = "Maximum shift allowed during alignment. Alignment will be slowed significantly as the maximum shift increases. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ringstep"; token.key_prefix = "--"; token.label = "Ring step"; token.help = "Alignments will be computed at this radial increment, in pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen, from 0..2. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_cinderella_pred"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Automatic 2D class selection"; sxcmd.short_info = "Classify classes into good and bad."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_isac"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "cinderella_path"; token.key_prefix = ""; token.label = "Cinderella predict executeable"; token.help = "Path to the sp_cinderella_predict.py in your Cinderella environment "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_stack_cinderella"; token.key_prefix = ""; token.label = "Input stack"; token.help = "Path to your class stack (.mrcs/.hdf). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to write results. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "model_path"; token.key_prefix = ""; token.label = "Model path"; token.help = "Specifiy the path to your model file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "confidence_threshold"; token.key_prefix = "--"; token.label = "Confidence threshold"; token.help = "Classes with a confidence higher as that threshold are classified as good. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "gpu"; token.key_prefix = "--"; token.label = "GPU ID"; token.help = "ID of the GPU that should be used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "batch_size"; token.key_prefix = "--"; token.label = "Number of batches"; token.help = "Number of mini-batches during prediction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "32"; token.restore = [['32'], ['32']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_rviper"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Initial 3D Model - RVIPER"; sxcmd.short_info = "Reproducible ab initio 3D structure determination. The program determines a validated initial intermediate resolution structure using a subset of class averages produced by ISAC2."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input images stack"; token.help = "Subset of class averages, e.g., produced by ISAC2. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The automatically-created output directory will contain results. If the directory already exists, results will be written there, possibly overwriting previous runs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Use the same value as in ISAC2. It has to be less than half the box size. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the particle. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "moon_elimination"; token.key_prefix = "--"; token.label = "Eliminate disconnected regions"; token.help = "Used to removed disconnected pieces from the model. As an argument it requires a comma-separated string with the mass in KDa and the pixel size in [A]. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "iteration_start"; token.key_prefix = "--"; token.label = "Restarting iteration"; token.help = "Iteration from which to restart the program. 0 means go to the most recent one. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "n_rv_runs"; token.key_prefix = "--"; token.label = "RVIPER iterations"; token.help = "Corresponds to main### output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "10"; token.restore = [['10'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "n_v_runs"; token.key_prefix = "--"; token.label = "Minimum number of VIPER runs per RVIPER iterations"; token.help = "Corresponds to run### output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "criterion_name"; token.key_prefix = "--"; token.label = "Stable projection criterion"; token.help = "Used to decide if the solution is stable, i.e., whether projection images adopt similar orientations in independent runs of the program. Valid options are: '80th percentile', or 'fastest increase in the last quartile'. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "80th percentile"; token.restore = [['80th percentile'], ['80th percentile']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_index_threshold_method"; token.key_prefix = "--"; token.label = "Outlier selection method"; token.help = "Used to decide which images to keep. Valid options are: 'discontinuity_in_derivative', 'percentile', or 'angle_measure'. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "discontinuity_in_derivative"; token.restore = [['discontinuity_in_derivative'], ['discontinuity_in_derivative']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "angle_threshold"; token.key_prefix = "--"; token.label = "Angle threshold"; token.help = "Threshold used to remove projections if 'angle_measure' is used to decide the outliers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "30"; token.restore = [['30'], ['30']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_percentile"; token.key_prefix = "--"; token.label = "Percentile for outlier"; token.help = "Threshold above which images are considered outliers and removed if 'percentile' is used as outlier selection method. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "95.0"; token.restore = [['95.0'], ['95.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ir"; token.key_prefix = "--"; token.label = "Inner rotational search radius [Pixels]"; token.help = "Inner rotational search radius [Pixels]. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rs"; token.key_prefix = "--"; token.label = "Ring step size [Pixels]"; token.help = "Step between rings used for the rotational search. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "X search range [Pixels]"; token.help = "The translational search range in the x direction. Search will +/-xr range in steps of ts. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "yr"; token.key_prefix = "--"; token.label = "Y search range [Pixels]"; token.help = "The translational search range in the y direction. If omitted it will be equal to the x search range. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Translational search step [Pixels]"; token.help = "The search will be performed in -xr, -xr+ts, 0, xr-ts, xr, can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Projection angular step [Degrees]"; token.help = "Projection angular step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center"; token.key_prefix = "--"; token.label = "Center 3D template"; token.help = "-1: center of coordinates, 0: no centering; 1: center of gravity "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit1"; token.key_prefix = "--"; token.label = "Maximum iterations - GA step"; token.help = "Maximum number of iterations for GA step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "400"; token.restore = [['400'], ['400']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit2"; token.key_prefix = "--"; token.label = "Maximum iterations - Finish step"; token.help = "Maximum iterations number of for Finish step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "50"; token.restore = [['50'], ['50']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask"; token.help = "Path to 3D mask file. By default, a spherical mask will be used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['filament_width', '-1', 'False']]; token.default = "sphere"; token.restore = [['sphere'], ['sphere']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_width', []).append([token.key_base, '-1', 'False']) - token = SXcmd_token(); token.key_base = "L2threshold"; token.key_prefix = "--"; token.label = "GA stop threshold"; token.help = "Defines the maximum relative dispersion of structures' L2 norms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.03"; token.restore = [['0.03'], ['0.03']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ref_a"; token.key_prefix = "--"; token.label = "Projection generation method"; token.help = "Method for generating the quasi-uniformly distributed projection directions. S - Saff algorithm, M - Markus 2019 algorithm or P - Penczek 1994 algorithm. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'P', 'M'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "n_shc_runs"; token.key_prefix = "--"; token.label = "GA population size"; token.help = "This defines the number of quasi-independent structures generated. (same as --nruns parameter from sp_viper). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "doga"; token.key_prefix = "--"; token.label = "Threshold to start GA"; token.help = "Do GA when the fraction of orientation that changes less than 1.0 degrees is at least this fraction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [1/Pixels]"; token.help = "Using a hyperbolic tangent low-pass filter. Specify with absolute frequency. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.25"; token.restore = [['0.25'], ['0.25']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Fall-off of for the hyperbolic tangent low-pass filter. Specify with absolute frequency. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pwreference"; token.key_prefix = "--"; token.label = "Power spectrum reference"; token.help = "Text file containing a 1D reference power spectrum. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "spectrum1d"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "npad"; token.key_prefix = "--"; token.label = "Image padding factor"; token.help = "Used by 3D reconstruction algorithm in the program. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta1"; token.key_prefix = "--"; token.label = "Minimum theta"; token.help = "Lower bound for out-of-plane tilt angle. No tilt corresponds to 90 degrees. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta2"; token.key_prefix = "--"; token.label = "Maximum theta"; token.help = "Upper bound for out-of-plane tilt angle. No tilt corresponds to 90 degrees. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "BILD resolution"; token.help = "Resolution in dpi for angular distribution plot. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "72"; token.restore = [['72'], ['72']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [Pixels]"; token.help = "When this is set to a non-default value helical data is assumed in which case the input images will be aligned to a mask with this width. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['mask3D', 'sphere', 'False']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mask3D', []).append([token.key_base, 'sphere', 'False']) - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['filament_width', '-1', 'True'], ['mask3D', 'sphere', 'False']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('filament_width', []).append([token.key_base, '-1', 'True']); sxcmd.dependency_dict.setdefault('mask3D', []).append([token.key_base, 'sphere', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_proj_compare"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compare Re-projections"; sxcmd.short_info = "Compare re-projections to class averages."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Set of 2D images to be compared, i.e., class averages. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input volume"; token.help = "Reconstruction for which re-projections will be computed. In RVIPER, this file is of the form main003/run002/rotated_volume.hdf. This volume must have the same dimensions as the input images. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mode"; token.key_prefix = "--"; token.label = "Comparison method"; token.help = "Choices are: viper, projmatch, and meridien. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "projmatch"; token.restore = [['projmatch', 'viper', 'meridien'], ['projmatch', 'viper', 'meridien']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "classangles"; token.key_prefix = "--"; token.label = "VIPER - Projection parameter file"; token.help = "Parameter file containing projection angles. Not required if the projection parameters are stored in the header of the input images, which for ISAC2 is generally not the case. In RVIPER, this file is of the form main003/run002/rotated_reduced_params.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) - token = SXcmd_token(); token.key_base = "classselect"; token.key_prefix = "--"; token.label = "VIPER - Image selection file"; token.help = "Input selection containing list of images to be included from the input stack. For instance, RVIPER, if it finds a stable solution, may exclude some images, and thus their projection angles will be excluded from the parameters file. The file containing the list of included images will have a name like main003/index_keep_image.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "ProjMatch - Sampling angle"; token.help = "Angular-sampling for reference projections. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "ProjMatch - Symmetry"; token.help = "To limit angular projections. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "partangles"; token.key_prefix = "--"; token.label = "MERIDIEN - Alignment parameter file"; token.help = "Input refinement parameter file, e.g., Refine3D/final_params_037.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "partselect"; token.key_prefix = "--"; token.label = "MERIDIEN - Particle selection file"; token.help = "Input substack selection file if particles removed before refinement, e.g., Substack/isac_substack_particle_id_list.txt. This file is used to map the particle number before classification to particle number in refinement. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "outliers"; token.key_prefix = "--"; token.label = "MERIDIEN - Outlier angle"; token.help = "Particles differing from average Euler angle by more than this threshold (in degrees) will be excluded from average calculation, by default keeps all. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "prjmethod"; token.key_prefix = "--"; token.label = "Interpolation method"; token.help = "Valid choices are trilinear, gridding, and nn. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "trilinear"; token.restore = [['trilinear', 'gridding', 'nn'], ['trilinear', 'gridding', 'nn']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "display"; token.key_prefix = "--"; token.label = "e2display"; token.help = "Automatically pops up a window with the output montage. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "matchshift"; token.key_prefix = "--"; token.label = "ProjMatch - Maximum shift"; token.help = "Maximum shift to allow during translation alignment, pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "matchrad"; token.key_prefix = "--"; token.label = "ProjMatch - Outer radius"; token.help = "Outer alignment radius, defaults to automatically-determined. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "matchstep"; token.key_prefix = "--"; token.label = "ProjMatch - Radius step size"; token.help = "Alignment radius step size. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "refinerad"; token.key_prefix = "--"; token.label = "MERIDIEN - Outer radius"; token.help = "Outer alignment radius, defaults to automatically-determined. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "refineshift"; token.key_prefix = "--"; token.label = "MERIDIEN - Maximum shift"; token.help = "Maximum shift to allow during translation alignment, pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "refinestep"; token.key_prefix = "--"; token.label = "MERIDIEN - Radius step size"; token.help = "Alignment radius step size. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "align"; token.key_prefix = "--"; token.label = "MERIDIEN - Alignment method"; token.help = "Valid choices are apsh and scf. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "apsh"; token.restore = [['apsh', 'scf'], ['apsh', 'scf']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_viper"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Initial 3D Model - VIPER"; sxcmd.short_info = "ab initio 3D structure determination using Validation of Individual Parameter Reproducibility (VIPER). Determines a validated initial model using a small set of class averages produced by ISAC2."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input images stack"; token.help = "A small subset of class averages produced by ISAC2. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The automatically-created output directory will contain results. If the directory already exists, results will be written there, possibly overwriting previous runs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Use the same value as in ISAC2. It has to be less than half the box size. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the particle. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "moon_elimination"; token.key_prefix = "--"; token.label = "Eliminate disconnected regions"; token.help = "Used to removed disconnected pieces from the model. As an argument it requires a comma-separated string with the mass in KDa and the pixel size in [A]. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ir"; token.key_prefix = "--"; token.label = "Inner rotational search radius [Pixels]"; token.help = "Inner rotational search radius [Pixels]. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rs"; token.key_prefix = "--"; token.label = "Ring step size [Pixels]"; token.help = "Step between rings used for the rotational search. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "X search range [Pixels]"; token.help = "The translational search range in the x direction. Search will be +/-xr in steps of ts. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "yr"; token.key_prefix = "--"; token.label = "Y search range [Pixels]"; token.help = "The translational search range in the y direction. If omitted, it will be set to xr. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Translational search step [Pixels]"; token.help = "The search will be performed in -xr, -xr+ts, 0, xr-ts, xr, can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Projection angular step [Degrees]"; token.help = "Projection angular step, degrees. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center"; token.key_prefix = "--"; token.label = "Centering method"; token.help = "For 3D template, -1: center of coordinates, 0: no centering; 1: center of gravity "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit1"; token.key_prefix = "--"; token.label = "Maximum iterations - GA step"; token.help = "Maximum number of iterations for GA step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "400"; token.restore = [['400'], ['400']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxit2"; token.key_prefix = "--"; token.label = "Maximum iterations - Finish step"; token.help = "Maximum iterations number of for Finish step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "50"; token.restore = [['50'], ['50']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask"; token.help = "Path to 3D mask file. By default, a spherical mask will be used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sphere"; token.restore = [['sphere'], ['sphere']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "L2threshold"; token.key_prefix = "--"; token.label = "GA stop threshold"; token.help = "Defines the maximum relative dispersion of structures' L2 norms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.03"; token.restore = [['0.03'], ['0.03']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ref_a"; token.key_prefix = "--"; token.label = "Projection generation method"; token.help = "Method for generating the quasi-uniformly distributed projection directions. S - Saff algorithm, or P - Penczek 1994 algorithm. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S'], ['S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nruns"; token.key_prefix = "--"; token.label = "Number of runs"; token.help = "GA population size, i.e., the number of quasi-independent structures generated. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "6"; token.restore = [['6'], ['6']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "doga"; token.key_prefix = "--"; token.label = "Threshold to start GA"; token.help = "Do GA when the fraction of orientation that changes less than 1.0 degrees is at least this fraction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [1/Pixels]"; token.help = "Using a hyperbolic tangent low-pass filter. Specify with absolute frequency. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.25"; token.restore = [['0.25'], ['0.25']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Fall-off of for the hyperbolic tangent low-pass filter. Specify with absolute frequency. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pwreference"; token.key_prefix = "--"; token.label = "Power spectrum reference"; token.help = "Text file containing a 1D reference power spectrum. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "spectrum1d"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Print debug info. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pdb2em"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "PDB File Conversion"; sxcmd.short_info = "Converts an atomic model stored in a PDB file into a simulated electron density map."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_pdb"; token.key_prefix = ""; token.label = "Input PDB file"; token.help = "Starting atomic coordinates. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "pdb"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_hdf"; token.key_prefix = ""; token.label = "Output map"; token.help = "Specify file path for output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size of output map [A]"; token.help = "Pixel size of the output map [A]. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box"; token.key_prefix = "--"; token.label = "Output box size [Voxels]"; token.help = "Specify string of a single value (e.g. '256') to get a cubic box. Alternatively, use 'x,y,z' format to specify demensions of x,y,z-axis (e.g. '128,64,256'). If not given, the program will find the minimum box size fitting the structure. Be aware that this will most likely result in a rectangular box. Note that GUI does not support the default mode. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "het"; token.key_prefix = "--"; token.label = "Include hetero atoms"; token.help = "Otherwise, the HETATM entries in the PDB file are ignored. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chains"; token.key_prefix = "--"; token.label = "Chain identifiers"; token.help = "A string list of chain identifiers to include (e.g. 'ABEFG'). By default, all chains will be included. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center"; token.key_prefix = "--"; token.label = "Center model at the origin"; token.help = "Specifies whether the atomic model should be moved to the origin before generating density map. Available options are: 'c' - Use the geometrical center of atoms; 'a' - Use the center of mass (recommended); 'x,y,z' - Vector to be subtracted from all PDB coordinates. 'n' - No centering, in which case (0,0,0) in the PDB space will map to the center of the EM volume. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "a"; token.restore = [['a'], ['a']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "O"; token.key_prefix = "--"; token.label = "Apply additional rotation"; token.help = "This can be used to modify the orientation of the atomic model by using O system of coordinates. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "tr0"; token.key_prefix = "--"; token.label = "Rotational matrix file"; token.help = "This file must contain the 3x4 transformation matrix to be applied to the PDB coordinates after centering. The translation vector (last column of the matrix) must be specified in Angstrom. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "rot_matrix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "set_apix_value"; token.key_prefix = "--"; token.label = "Set header pixel size"; token.help = "Set pixel size in header of the ouput map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "quiet"; token.key_prefix = "--"; token.label = "Silent mode"; token.help = "Does not print any information to the monitor. Verbose is the default. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_viper"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Refinement"; sxcmd.short_info = "Performs 3D structure refinement using a quasi-Maximum Likelihood approach."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Input image stack. Required for new runs, not for restarts. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "initial_volume"; token.key_prefix = ""; token.label = "Initial 3D reference"; token.help = "The 3D reference used in the initial iteration of 3D refinement. Required only for new runs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "initialshifts"; token.key_prefix = "--"; token.label = "Read shifts from header"; token.help = "Start refinement using translation parameters located in the input file header to jumpstart the procedure. Specific to standard run mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = True; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_prealignment"; token.key_prefix = "--"; token.label = "Skip the 2D pre-alignment step"; token.help = "Indicate if pre-alignment should be omitted. By default it is performed in order to find initial translation parameters. This accelerates convergence of the program. Do not use 2D pre-alignment if images are already centered. Specific to standard run modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['initialshifts', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('initialshifts', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "center_method"; token.key_prefix = "--"; token.label = "Centering method"; token.help = "Method for centering averages during initial 2D prealignment of data (0: no centering; -1: average shift method; For 1-7, see center_2D in utilities.py). Specific to standard run modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_radius"; token.key_prefix = "--"; token.label = "Target particle radius [Pixels]"; token.help = "For 2D prealignment, images will be shrunk or enlarged to this radius. Specific to standard run modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "25.0"; token.restore = [['25.0'], ['25.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_gui_meridien"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Refinement Assessment"; sxcmd.short_info = "GUI tool to assess 3D Refinement based on outputs of sp_meridien."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = False - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sxresolution"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compute mFSC"; sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "Volume #1"; token.help = "First unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Volume #2"; token.help = "Second unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maskfile"; token.key_prefix = ""; token.label = "3D mask"; token.help = "Defines the region within which FSCM will be computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputdir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where output files will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Mask radius"; token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) - token = SXcmd_token(); token.key_base = "wn"; token.key_prefix = "--"; token.label = "Window size"; token.help = "Size of window within which local real-space FSC is computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "15"; token.restore = [['15'], ['15']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "local_fsc"; token.key_prefix = "--"; token.label = "Compute local resolution"; token.help = "Set to 1 to compute local resolution volume. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0', '1'], ['0', '1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sigmag"; token.key_prefix = "--"; token.label = "Sigma of Gaussian window"; token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Shell step"; token.help = "Shell step in Fourier size in pixels (integer). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "lfi"; token.key_prefix = "--"; token.label = "Inner radius"; token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hfi"; token.key_prefix = "--"; token.label = "Outer radius"; token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "significance"; token.key_prefix = "--"; token.label = "Significance level"; token.help = "Significance level for the upper confidence interval "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.99"; token.restore = [['0.99'], ['0.99']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndf_reduce"; token.key_prefix = "--"; token.label = "Number of asymmetric units"; token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cutoff"; token.key_prefix = "--"; token.label = "FSC criterion"; token.help = "Resolution cut-off for FSCM confidence interval. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.143"; token.restore = [['0.143'], ['0.143']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nthreads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "Number of threads (mainly for 3D FFT). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "combinemaps"; sxcmd.subset_config = "halfset maps"; sxcmd.label = "PostRefiner"; sxcmd.short_info = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "combinemaps"; token.key_prefix = "--"; token.label = "Post-refine halfset volumes"; token.help = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "First unfiltered halfset map"; token.help = "As generated by sxmeridien."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Second unfiltered halfset map"; token.help = "As generated by sxmeridien."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of input data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "Path to user-provided mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "do_adaptive_mask"; token.key_prefix = "--"; token.label = "Apply adaptive mask"; token.help = "Program creates mask adaptively with given density threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "-9999.0"; token.restore = [['-9999.0'], ['-9999.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "do_approx"; token.key_prefix = "--"; token.label = "Approximate values"; token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mtf"; token.key_prefix = "--"; token.label = "MTF file"; token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mtf"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fsc_adj"; token.key_prefix = "--"; token.label = "Apply FSC-based low-pass filter"; token.help = "Applies an FSC-based low-pass filter to the merged map before the B-factor estimation. Effective only in Halfset Volumes Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_enhance"; token.key_prefix = "--"; token.label = "B-factor enhancement"; token.help = "0.0: program automatically estimates B-factor using power spectrum at frequencies from B_start (usually 10 Angstrom) to the resolution determined by FSC143 (valid only in Halfset Volumes Mode; Non-zero positive value: program use the given value [A^2] to enhance map); -1.0: B-factor is not applied. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_start"; token.key_prefix = "--"; token.label = "B-factor estimation lower limit [A]"; token.help = "Frequency in Angstrom defining lower boundary of B-factor estimation. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) - token = SXcmd_token(); token.key_base = "B_stop"; token.key_prefix = "--"; token.label = "B-factor estimation upper limit [A]"; token.help = "Frequency in Angstrom defining upper boundary of B-factor estimation. Recommended to set the upper boundary to the frequency where FSC is smaller than 0.0. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [A]"; token.help = "0.0: low-pass filter to resolution (valid only in Halfset Volumes Mode); A value larger than 0.5: low-pass filter to the value in Angstrom; -1.0: no low-pass filter. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "output"; token.key_prefix = "--"; token.label = "Output file name"; token.help = "File name of output final post-refined structure. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol_combined.hdf"; token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sxresolution"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compute mFSC"; sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "Volume #1"; token.help = "First unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Volume #2"; token.help = "Second unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maskfile"; token.key_prefix = ""; token.label = "3D mask"; token.help = "Defines the region within which FSCM will be computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputdir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where output files will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Mask radius"; token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) - token = SXcmd_token(); token.key_base = "wn"; token.key_prefix = "--"; token.label = "Window size"; token.help = "Size of window within which local real-space FSC is computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "15"; token.restore = [['15'], ['15']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "local_fsc"; token.key_prefix = "--"; token.label = "Compute local resolution"; token.help = "Set to 1 to compute local resolution volume. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0', '1'], ['0', '1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sigmag"; token.key_prefix = "--"; token.label = "Sigma of Gaussian window"; token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Shell step"; token.help = "Shell step in Fourier size in pixels (integer). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "lfi"; token.key_prefix = "--"; token.label = "Inner radius"; token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hfi"; token.key_prefix = "--"; token.label = "Outer radius"; token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "significance"; token.key_prefix = "--"; token.label = "Significance level"; token.help = "Significance level for the upper confidence interval "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.99"; token.restore = [['0.99'], ['0.99']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndf_reduce"; token.key_prefix = "--"; token.label = "Number of asymmetric units"; token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cutoff"; token.key_prefix = "--"; token.label = "FSC criterion"; token.help = "Resolution cut-off for FSCM confidence interval. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.143"; token.restore = [['0.143'], ['0.143']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nthreads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "Number of threads (mainly for 3D FFT). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_header"; sxcmd.subname = ""; sxcmd.mode = "import"; sxcmd.subset_config = ""; sxcmd.label = "Import Projection Parameters"; sxcmd.short_info = "Import projection orientation parameters to the header of the input stack. (Five columns: phi, theta, pshi, sx, sy). These parameters are required by 'Local Refinement from Stack' mode."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "import"; token.key_prefix = "--"; token.label = "Import parameters"; token.help = "Import parameters from file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params"; token.key_prefix = "--"; token.label = "Target parameters"; token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [['xform.projection'], ['xform.projection']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "stack"; sxcmd.label = "Local Refinement from Stack"; sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "iteration"; sxcmd.label = "Restart Local Refinement"; sxcmd.short_info = "Restart local refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same as in the original run."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Directory"; token.help = "This directory must exist. The results will be written there."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = "restart"; sxcmd.label = "3D Refinement Restart"; sxcmd.short_info = "Restart 3D refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Output Directory"; token.help = "This directory must exist. The results will be written here."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "25.0"; token.restore = [['25.0'], ['25.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "do_final"; sxcmd.subset_config = ""; sxcmd.label = "Final 3D Reconstruction Only"; sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "do_final"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Output Directory"; token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien_alpha"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = "beta"; sxcmd.label = "3D Refinement (Alpha)"; sxcmd.short_info = "Performs 3D structure refinement for helical specimen using a quasi-Maximum Likelihood approach."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Input image stack. Required for new runs, not for restarts. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "initial_volume"; token.key_prefix = ""; token.label = "Initial 3D reference"; token.help = "The 3D reference used in the initial iteration of 3D refinement. Required only for new runs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "initialshifts"; token.key_prefix = "--"; token.label = "Read shifts from header"; token.help = "Start refinement using translation parameters located in the input file header to jumpstart the procedure. Specific to standard run mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = True; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_prealignment"; token.key_prefix = "--"; token.label = "Skip the 2D pre-alignment step"; token.help = "Indicate if pre-alignment should be omitted. By default it is performed in order to find initial translation parameters. This accelerates convergence of the program. Do not use 2D pre-alignment if images are already centered. Specific to standard run modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['initialshifts', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('initialshifts', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "center_method"; token.key_prefix = "--"; token.label = "Centering method"; token.help = "Method for centering averages during initial 2D prealignment of data (0: no centering; -1: average shift method; For 1-7, see center_2D in utilities.py). Specific to standard run modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_radius"; token.key_prefix = "--"; token.label = "Target particle radius [Pixels]"; token.help = "For 2D prealignment, images will be shrunk or enlarged to this radius. Specific to standard run modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "29"; token.restore = [['29'], ['29']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "25.0"; token.restore = [['25.0'], ['25.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta_min"; token.key_prefix = "--"; token.label = "Theta min [degree]"; token.help = "Minimum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta_max"; token.key_prefix = "--"; token.label = "Theta max [degree]"; token.help = "Maximum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "angle_method"; token.key_prefix = "--"; token.label = "Even angle method"; token.help = "Method to use for even angle creation (S, M, P). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk_by"; token.key_prefix = "--"; token.label = "Group name for chunks"; token.help = "Group the particles by the specified header name before splitting them into chunks. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "ptcl_source_image"; token.restore = [['ptcl_source_image'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_by"; token.key_prefix = "--"; token.label = "Outlier group ID"; token.help = "Group the particles by the header name for outlier detection. By default do not perform outlier detection. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [px]"; token.help = "This is used to normalize the particles in case of filaments. A rectangular mask will be used instead of a circular one. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "helical_rise"; token.key_prefix = "--"; token.label = "Helical rise [A]"; token.help = "Helical rise used to limit the shift along the helical axis to +-rise/2 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "plot_ang_dist"; token.key_prefix = "--"; token.label = "Plot angular distribution"; token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_tracker"; token.key_prefix = "--"; token.label = "Outlier Tracker"; token.help = "Tracker from a previous MERIDIEN directory that ran with the same stack to skip the OUTLIER finding. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_json"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "howmany"; token.key_prefix = "--"; token.label = "Howmany value"; token.help = "Howmany neighbors shouls be taken into account for the exhaustive step of the refinementHowmany neighbors shouls be taken into account for the exhaustive step of the refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - # sxcmd = SXcmd(); sxcmd.name = "sp_meridien_alpha"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "stack_beta"; sxcmd.label = "Local Refinement from Stack (Beta)"; sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - # token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "theta_min"; token.key_prefix = "--"; token.label = "Theta min [degree]"; token.help = "Minimum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "theta_max"; token.key_prefix = "--"; token.label = "Theta max [degree]"; token.help = "Maximum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "angle_method"; token.key_prefix = "--"; token.label = "Even angle method"; token.help = "Method to use for even angle creation (S, M, P). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "chunk_by"; token.key_prefix = "--"; token.label = "Group name for chunks"; token.help = "Group the particles by the specified header name before splitting them into chunks. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "ptcl_source_image"; token.restore = [['ptcl_source_image'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "outlier_by"; token.key_prefix = "--"; token.label = "Outlier group ID"; token.help = "Group the particles by the header name for outlier detection. By default do not perform outlier detection. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [px]"; token.help = "This is used to normalize the particles in case of filaments. A rectangular mask will be used instead of a circular one. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "helical_rise"; token.key_prefix = "--"; token.label = "Helical rise [A]"; token.help = "Helical rise used to limit the shift along the helical axis to +-rise/2 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "plot_ang_dist"; token.key_prefix = "--"; token.label = "Plot angular distribution"; token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "outlier_tracker"; token.key_prefix = "--"; token.label = "Outlier Tracker"; token.help = "Tracker from a previous MERIDIEN directory that ran with the same stack to skip the OUTLIER finding. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_json"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # token = SXcmd_token(); token.key_base = "howmany"; token.key_prefix = "--"; token.label = "Howmany value"; token.help = "Howmany neighbors shouls be taken into account for the exhaustive step of the refinementHowmany neighbors shouls be taken into account for the exhaustive step of the refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - # - # sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien_alpha"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "iteration_beta"; sxcmd.label = "Restart Local Refinement (Beta)"; sxcmd.short_info = "Restart local refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same as in the original run."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Directory"; token.help = "This directory must exist. The results will be written there."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta_min"; token.key_prefix = "--"; token.label = "Theta min [degree]"; token.help = "Minimum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "theta_max"; token.key_prefix = "--"; token.label = "Theta max [degree]"; token.help = "Maximum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['90']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "angle_method"; token.key_prefix = "--"; token.label = "Even angle method"; token.help = "Method to use for even angle creation (S, M, P). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk_by"; token.key_prefix = "--"; token.label = "Group name for chunks"; token.help = "Group the particles by the specified header name before splitting them into chunks. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "ptcl_source_image"; token.restore = [['ptcl_source_image'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_by"; token.key_prefix = "--"; token.label = "Outlier group ID"; token.help = "Group the particles by the header name for outlier detection. By default do not perform outlier detection. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['filament_id']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filament_width"; token.key_prefix = "--"; token.label = "Filament width [px]"; token.help = "This is used to normalize the particles in case of filaments. A rectangular mask will be used instead of a circular one. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "filament_width"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "helical_rise"; token.key_prefix = "--"; token.label = "Helical rise [A]"; token.help = "Helical rise used to limit the shift along the helical axis to +-rise/2 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "plot_ang_dist"; token.key_prefix = "--"; token.label = "Plot angular distribution"; token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outlier_tracker"; token.key_prefix = "--"; token.label = "Outlier Tracker"; token.help = "Tracker from a previous MERIDIEN directory that ran with the same stack to skip the OUTLIER finding. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_json"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "howmany"; token.key_prefix = "--"; token.label = "Howmany value"; token.help = "Howmany neighbors shouls be taken into account for the exhaustive step of the refinementHowmany neighbors shouls be taken into account for the exhaustive step of the refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien_alpha"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = "restart_beta"; sxcmd.label = "3D Refinement Restart (Beta)"; sxcmd.short_info = "Restart 3D refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Output Directory"; token.help = "This directory must exist. The results will be written here."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "25.0"; token.restore = [['25.0'], ['25.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "plot_ang_dist"; token.key_prefix = "--"; token.label = "Plot angular distribution"; token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien_alpha"; sxcmd.subname = ""; sxcmd.mode = "do_final"; sxcmd.subset_config = ""; sxcmd.label = "Final 3D Reconstruction Only (Beta)"; sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "do_final"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Output Directory"; token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "balance_angular_distribution"; sxcmd.subset_config = ""; sxcmd.label = "Balance Angular Distribution"; sxcmd.short_info = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "balance_angular_distribution"; token.key_prefix = "--"; token.label = "Balance Angular Distribution"; token.help = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_any_txt"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "Typically from MERIDIEN with a filename in the form of Refine3D/final_params_0##.txt"; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Output selection list"; token.help = "Text file with a list of retained particle images"; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "max_occupy"; token.key_prefix = "--"; token.label = "Maximum orientations per reference angle"; token.help = "Maximum number of particles per reference angle. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "angstep"; token.key_prefix = "--"; token.label = "Angular increment"; token.help = "Angular step of reference angles. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "15"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "angular step of reference angles, i.e., number of bins of angular histogram. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "meridien"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Meridien)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "refinement_dir"; token.key_prefix = ""; token.label = "Meridien directory"; token.help = "Path to Meridien directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "manual"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Stack)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_meridien"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume_path"; token.key_prefix = ""; token.label = "Path to volume"; token.help = "Path to volume. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Params file"; token.help = "Path to params file "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk"; token.key_prefix = "--"; token.label = "Path to chunk file"; token.help = "Path to chunk file "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume2"; token.key_prefix = "--"; token.label = "Path to second volume"; token.help = "Path to second half volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_header"; sxcmd.subname = ""; sxcmd.mode = "import"; sxcmd.subset_config = ""; sxcmd.label = "Import Projection Parameters"; sxcmd.short_info = "Import projection orientation parameters from a file (for example created by sxmeridien) to header of the input stack; they are required by 3DVARIABILITY.py and SORT3D_DEPTH Stack Mode."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "import"; token.key_prefix = "--"; token.label = "Import parameters"; token.help = "Import parameters from file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params"; token.key_prefix = "--"; token.label = "Target parameters"; token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [['xform.projection'], ['xform.projection']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_3dvariability"; sxcmd.subname = ""; sxcmd.mode = "symmetrize"; sxcmd.subset_config = ""; sxcmd.label = "3D Variability Preprocess"; sxcmd.short_info = "Prepare input stack for handling symmetry. Please skip this preparation step if the structure is asymmetrical (i.e. c1), since it is required only when the structure has internal symmetry. Notice this step can be run with only one CPU and there is no MPI version for it. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "symmetrize"; token.key_prefix = "--"; token.label = "Symmetrise input stack"; token.help = "Prepare input stack for handling symmetry. Please skip this preparation step if the structure is asymmetrical (i.e. c1), since it is required only when the structure has internal symmetry. Notice this step can be run with only one CPU and there is no MPI version for it. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prj_stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The images must contain the 3D orientation parameters in headers and optionally also CTF information. The output image stack is bdb:sdata. Please use it as an input image stack of sx3dvariability."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory of 3D Variability. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "If the structure has symmetry higher than c1, the command requires symmetrization of the dataset, using --symmetrize option, before computing 3D variability. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_3dvariability"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Variability Estimation"; sxcmd.short_info = "Calculate 3D variability using a set of aligned projection images as an input."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "prj_stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The images must containt the 3D orientation parameters in the header and optionally CTF information. If the structure has a symmetry higher than c1, please specify the image stack which is prepared by the symmetrization using --symmetrize option. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory of 3D Variability. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "var3D"; token.key_prefix = "--"; token.label = "Output 3D variability"; token.help = "Specify a file name to indicate if the program should write the reconstructed 3D variability map to the disk. The 3D volume will contain, for each voxel, a measure of the variability in the dataset. Careful, time consuming! "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ave3D"; token.key_prefix = "--"; token.label = "Output 3D average"; token.help = "Specify a file name to indicate if the program should write the reconstructed 3D average map to the disk. The 3D map will be reconstructed from projections averaged within respective angular neighbourhood. It should be used to assess the resolvability and possible artifacts of the variability map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp"; token.key_prefix = "--"; token.label = "Number of projections"; token.help = "Specify the number of images from the angular neighbourhood that will be used to estimate 2D variance for each projection data. The larger the number the less noisy the estimate, but the lower the resolution. Usage of large number also results in rotational artifacts in variances that will be visible in 3D variability map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "If the structure has symmetry higher than c1, the command requires symmetrization of the dataset, using --symmetrize option, before computing 3D variability. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "CTF"; token.key_prefix = "--"; token.label = "Use CTF correction"; token.help = "If set to true, CTF correction will be applied using the parameters found in the image headers. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = True; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overhead"; token.key_prefix = "--"; token.label = "Python overhead memory"; token.help = "User estimates python overhead memory per CPU. The default value is 0.5 GB per CPU. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "var2D"; token.key_prefix = "--"; token.label = "Output 2D variances"; token.help = "Specify a file name to indicate if the program should write the stack of computed 2D variances to the disk. Useful for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ave2D"; token.key_prefix = "--"; token.label = "Output 2D averages"; token.help = "Specify a file name to indicate if the program should write the stack of computed 2D averages to the disk. Useful for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "VAR"; token.key_prefix = "--"; token.label = "Input stack consists of 2D variances"; token.help = "Stack on input consists of 2D variances. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "no_norm"; token.key_prefix = "--"; token.label = "Apply normalization"; token.help = "Indicate if normalization should be applied or not. By default, apply normalization. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "npad"; token.key_prefix = "--"; token.label = "Image padding factor"; token.help = "The number of time to pad the original images. The images will be padded to achieve the original size times this option. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "decimate"; token.key_prefix = "--"; token.label = "Image decimate factor"; token.help = "Reduce images by this factor and change the pixel size. Specify a non-zero positive float value smaller than 1.0. By default, it does not change size of images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.25"; token.restore = [['0.25'], ['0.25']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency"; token.help = "Stop-band frequency of the low-pass filter to be applied to the images prior to variability calculation but after decimation. Specify it in absolute frequency (> 0.0 and <= 0.5). By default, no filtering. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "abs_freq"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off"; token.help = "Fall-off width of the low-pass filter to be applied to the images prior to variability calculation but after decimation. Specify it in absolute frequency (> 0.0 and <= 0.5). 0.01 works in most of cases. Effective only with --fl > 0.0 and --aa > 0.0 has to be specified. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '0.0', 'True']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '0.0', 'True']) - token = SXcmd_token(); token.key_base = "window"; token.key_prefix = "--"; token.label = "Target image size [Pixels]"; token.help = "Window (or clip) images using the specified size without changing pixel size. It is relative to the orignal window size. The target window size cannot be larger than the orignal image size. By default, use the original particle image size. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nvec"; token.key_prefix = "--"; token.label = "Number of eigenvectors"; token.help = "By default, no PCA will be calculated. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_sort3d_depth"; sxcmd.subname = ""; sxcmd.mode = "refinement_dir"; sxcmd.subset_config = ""; sxcmd.label = "3D Clustering from Iteration - SORT3D_DEPTH"; sxcmd.short_info = "Initialize from a given iteration of meridien run using the associated parameters, i.e., full set of orientation parameters per image, including orientation probabilities, normalizations and so on."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "refinement_dir"; token.key_prefix = "--"; token.label = "Meridien refinement directory"; token.help = "A string denotes meridien 3D refinement directory. Sorting switches to meridien iteration mode when specified. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "A string denotes output directory for 3D sorting. It can be either existing or non-existing. By default, the program uses sort3d_DATA_AND_TIME for the name. Here, you can find a log.txt that describes the sequences of computations in the program. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "niter_for_sorting"; token.key_prefix = "--"; token.label = "Iteration ID of 3D refinement for importing data"; token.help = "By default, the program uses the iteration at which refinement achieved the best resolution. Option is valid only for meridien iteration mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask"; token.help = "A string denotes file path of the global 3D mask for clustering. Imported from 3D refinement unless user wishes a different one in meridien iteration mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "focus"; token.key_prefix = "--"; token.label = "Focus 3D mask"; token.help = "A string denotes file path of a binary 3D mask for focused clustering. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Estimated particle radius [Pixels]"; token.help = "A integer value that is smaller than half of the box size. Imported from refinement unless user wishes a different one in meridien iteration mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "A string denotes point group symmetry of the macromolecular structure. Imported from refinement unless the user wishes a different one in meridien iteration mode. Require specification in stack mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp"; token.key_prefix = "--"; token.label = "Number of images per group"; token.help = "User expected group size in integer. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1000"; token.restore = [['1000'], ['1000']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp_split_rate"; token.key_prefix = "--"; token.label = "Group splitting rate"; token.help = "An integer value denotes split rate of the group size(--img_per_grp). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "minimum_grp_size"; token.key_prefix = "--"; token.label = "Minimum size of reproducible class"; token.help = "The minimum size of selected or accounted clusters as well as the minimum group size constraint in MGSKmeans. However this value must be smaller than the number of images per a group (img_per_grp). By default, the program uses half number of the images per group. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "do_swap_au"; token.key_prefix = "--"; token.label = "Swap flag"; token.help = "A boolean flag to control random swapping a certain number of accounted elements per cluster with the unaccounted elements. If the processing with the default values are extremely slow or stalled, please use this --do_swap_au option and set --swap_ratio to a large value (15.0[%] is a good start point). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "swap_ratio"; token.key_prefix = "--"; token.label = "Swap percentage [%]"; token.help = "the percentage of images for swapping ranges between 0.0[%] and 50.0[%]. Option valid only with --do_swap_au. Without --do_swap_au, the program automatically sets --swap_ratio to 0.0. If the processing with the default values are extremely slow or stalled, please use --do_swap_au and set this --swap_ratio option to a large value (15.0[%] is a good start point). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). It will be used to evaluate the number of CPUs per node from user-provided MPI setting. By default, it uses 2GB * (number of CPUs per node). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "depth_order"; token.key_prefix = "--"; token.label = "Depth order"; token.help = "An integer value defines the number of initial independent MGSKmeans runs (2^depth_order). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stop_mgskmeans_percentage"; token.key_prefix = "--"; token.label = "Image assignment percentage to stop MGSKmeans [%]"; token.help = "A floating number denotes particle assignment change percentage that serves as the converge criteria of minimum group size K-means. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nsmear"; token.key_prefix = "--"; token.label = "Number of smears for sorting"; token.help = "Fill it with 1 if user does not want to use all smears. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "orientation_groups"; token.key_prefix = "--"; token.label = "Number of orientation groups"; token.help = "Number of orientation groups in an asymmetric unit. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "not_include_unaccounted"; token.key_prefix = "--"; token.label = "Do unaccounted reconstruction"; token.help = "Do not reconstruct unaccounted elements in each generation. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "notapplybckgnoise"; token.key_prefix = "--"; token.label = "Use background noise flag"; token.help = "Flag to turn off background noise. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "random_group_elimination_threshold"; token.key_prefix = "--"; token.label = "Random group elimination threshold"; token.help = "A floating value denotes the random group reproducibility standard deviation for eliminating random groups. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2bdb"; sxcmd.subname = ""; sxcmd.mode = "makevstack"; sxcmd.subset_config = "subset"; sxcmd.label = "SORT3D_DEPTH Stack Subset"; sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "makevstack"; token.key_prefix = "--"; token.label = "Output stack subset"; token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_bdb_stack_file"; token.key_prefix = ""; token.label = "Original image stack"; token.help = "Specify path to input BDB stack file used for the associated SORT3D_DEPTH run."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Image selection file"; token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual BDB image stack from an existed stack or virtual stack. Typically, Cluster#.txt created by sxsort3d_depth (e.g. Cluster1.txt)."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "stack"; sxcmd.label = "Local Refinement from Stack"; sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "combinemaps"; sxcmd.subset_config = "halfset maps"; sxcmd.label = "PostRefiner"; sxcmd.short_info = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "combinemaps"; token.key_prefix = "--"; token.label = "Post-refine halfset volumes"; token.help = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "First unfiltered halfset map"; token.help = "As generated by sxmeridien."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Second unfiltered halfset map"; token.help = "As generated by sxmeridien."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of input data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "Path to user-provided mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "do_adaptive_mask"; token.key_prefix = "--"; token.label = "Apply adaptive mask"; token.help = "Program creates mask adaptively with given density threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "-9999.0"; token.restore = [['-9999.0'], ['-9999.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "do_approx"; token.key_prefix = "--"; token.label = "Approximate values"; token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mtf"; token.key_prefix = "--"; token.label = "MTF file"; token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mtf"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fsc_adj"; token.key_prefix = "--"; token.label = "Apply FSC-based low-pass filter"; token.help = "Applies an FSC-based low-pass filter to the merged map before the B-factor estimation. Effective only in Halfset Volumes Mode. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_enhance"; token.key_prefix = "--"; token.label = "B-factor enhancement"; token.help = "0.0: program automatically estimates B-factor using power spectrum at frequencies from B_start (usually 10 Angstrom) to the resolution determined by FSC143 (valid only in Halfset Volumes Mode; Non-zero positive value: program use the given value [A^2] to enhance map); -1.0: B-factor is not applied. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_start"; token.key_prefix = "--"; token.label = "B-factor estimation lower limit [A]"; token.help = "Frequency in Angstrom defining lower boundary of B-factor estimation. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) - token = SXcmd_token(); token.key_base = "B_stop"; token.key_prefix = "--"; token.label = "B-factor estimation upper limit [A]"; token.help = "Frequency in Angstrom defining upper boundary of B-factor estimation. Recommended to set the upper boundary to the frequency where FSC is smaller than 0.0. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [A]"; token.help = "0.0: low-pass filter to resolution (valid only in Halfset Volumes Mode); A value larger than 0.5: low-pass filter to the value in Angstrom; -1.0: no low-pass filter. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "output"; token.key_prefix = "--"; token.label = "Output file name"; token.help = "File name of output final post-refined structure. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol_combined.hdf"; token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_sort3d_depth"; sxcmd.subname = ""; sxcmd.mode = "instack"; sxcmd.subset_config = ""; sxcmd.label = "3D Clustering from Stack - SORT3D_DEPTH"; sxcmd.short_info = "Run from user-provided orientation parameters stored in stack header. This mode uses only highest probability orientation parameters per image, ths it should be avoided. This program is used only for testing."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "instack"; token.key_prefix = "--"; token.label = "Input images stack"; token.help = "A string denotes file path of input particle stack for sorting. Sorting switches to stack mode when option is specified. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "A string denotes output directory for 3D sorting. It can be either existing or non-existing. By default, the program uses sort3d_DATA_AND_TIME for the name. Here, you can find a log.txt that describes the sequences of computations in the program. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nxinit"; token.key_prefix = "--"; token.label = "Initial image size"; token.help = "Image size used for MGSKmeans in case of starting sorting from a data stack. By default, the program determines window size. Option is valid only for stack mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask"; token.help = "A string denotes file path of the global 3D mask for clustering. Imported from 3D refinement unless user wishes a different one in meridien iteration mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "focus"; token.key_prefix = "--"; token.label = "Focus 3D mask"; token.help = "A string denotes file path of a binary 3D mask for focused clustering. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Estimated particle radius [Pixels]"; token.help = "A integer value that is smaller than half of the box size. Imported from refinement unless user wishes a different one in meridien iteration mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "A string denotes point group symmetry of the macromolecular structure. Imported from refinement unless the user wishes a different one in meridien iteration mode. Require specification in stack mode. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp"; token.key_prefix = "--"; token.label = "Number of images per group"; token.help = "User expected group size in integer. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1000"; token.restore = [['1000'], ['1000']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "img_per_grp_split_rate"; token.key_prefix = "--"; token.label = "Group splitting rate"; token.help = "An integer value denotes split rate of the group size(--img_per_grp). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "minimum_grp_size"; token.key_prefix = "--"; token.label = "Minimum size of reproducible class"; token.help = "The minimum size of selected or accounted clusters as well as the minimum group size constraint in MGSKmeans. However this value must be smaller than the number of images per a group (img_per_grp). By default, the program uses half number of the images per group. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "do_swap_au"; token.key_prefix = "--"; token.label = "Swap flag"; token.help = "A boolean flag to control random swapping a certain number of accounted elements per cluster with the unaccounted elements. If the processing with the default values are extremely slow or stalled, please use this --do_swap_au option and set --swap_ratio to a large value (15.0[%] is a good start point). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "swap_ratio"; token.key_prefix = "--"; token.label = "Swap percentage [%]"; token.help = "the percentage of images for swapping ranges between 0.0[%] and 50.0[%]. Option valid only with --do_swap_au. Without --do_swap_au, the program automatically sets --swap_ratio to 0.0. If the processing with the default values are extremely slow or stalled, please use --do_swap_au and set this --swap_ratio option to a large value (15.0[%] is a good start point). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). It will be used to evaluate the number of CPUs per node from user-provided MPI setting. By default, it uses 2GB * (number of CPUs per node). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "depth_order"; token.key_prefix = "--"; token.label = "Depth order"; token.help = "An integer value defines the number of initial independent MGSKmeans runs (2^depth_order). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stop_mgskmeans_percentage"; token.key_prefix = "--"; token.label = "Image assignment percentage to stop MGSKmeans [%]"; token.help = "A floating number denotes particle assignment change percentage that serves as the converge criteria of minimum group size K-means. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10.0"; token.restore = [['10.0'], ['10.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nsmear"; token.key_prefix = "--"; token.label = "Number of smears for sorting"; token.help = "Fill it with 1 if user does not want to use all smears. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "orientation_groups"; token.key_prefix = "--"; token.label = "Number of orientation groups"; token.help = "Number of orientation groups in an asymmetric unit. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "not_include_unaccounted"; token.key_prefix = "--"; token.label = "Do unaccounted reconstruction"; token.help = "Do not reconstruct unaccounted elements in each generation. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "notapplybckgnoise"; token.key_prefix = "--"; token.label = "Use background noise flag"; token.help = "Flag to turn off background noise. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "random_group_elimination_threshold"; token.key_prefix = "--"; token.label = "Random group elimination threshold"; token.help = "A floating value denotes the random group reproducibility standard deviation for eliminating random groups. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "combinemaps"; sxcmd.subset_config = "single map"; sxcmd.label = "PostRefiner (Single Map)"; sxcmd.short_info = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "combinemaps"; token.key_prefix = "--"; token.label = "Post-refine single map"; token.help = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_pattern"; token.key_prefix = ""; token.label = "Input volume pattern"; token.help = "Specify path pattern of input single volumes with a wild card '*' or path to single volume file (without wild card '*'). Use the wild card to indicate the place of variable part of the file names. The path pattern must be enclosed by single quotes (') or double quotes (') (Note: sxgui.py automatically adds single quotes ('))."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of input data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "Path to user-provided mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "do_adaptive_mask"; token.key_prefix = "--"; token.label = "Apply adaptive mask"; token.help = "Program creates mask adaptively with given density threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "-9999.0"; token.restore = [['-9999.0'], ['-9999.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "do_approx"; token.key_prefix = "--"; token.label = "Approximate values"; token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "mtf"; token.key_prefix = "--"; token.label = "MTF file"; token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mtf"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_enhance"; token.key_prefix = "--"; token.label = "B-factor enhancement"; token.help = "Non-zero positive value: program use provided B-factor [A^2] to enhance the map; -1.0: B-factor is not applied."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [A]"; token.help = "A value larger than 0.5: low-pass filter to the resolution in Angstrom; -1.0: no low-pass filter."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "output"; token.key_prefix = "--"; token.label = "Output file name"; token.help = "File name of output final post-refined structure. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol_combined.hdf"; token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "do_final"; sxcmd.subset_config = ""; sxcmd.label = "Final 3D Reconstruction Only"; sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "do_final"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Output Directory"; token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_recons3d_n"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Reconstruction"; sxcmd.short_info = "3D Reconstruction using nearest-neighbor interpolation."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "prj_stack"; token.key_prefix = ""; token.label = "Input stack"; token.help = "Stack of projections "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_volume"; token.key_prefix = ""; token.label = "Output volume"; token.help = "Output reconstructed volume file "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Symmetry"; token.help = "Symmetry. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "CTF"; token.key_prefix = "--"; token.label = "Apply CTF"; token.help = "Apply CTF correction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Selection list"; token.help = "File with list of images to be used in the first column. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbosity"; token.help = "Enter 0 for no verbosity, 1 for verbose output. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "begin"; token.key_prefix = ""; token.label = "First image"; token.help = "First image for reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "end"; token.key_prefix = ""; token.label = "Last image"; token.help = "Last image for reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = ""; token.label = "Image step"; token.help = "Increment used for image list. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "snr"; token.key_prefix = "--"; token.label = "SNR"; token.help = "Signal-to-Noise Ratio. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "group"; token.key_prefix = "--"; token.label = "Group number"; token.help = "Perform reconstruction using images for a given group number (group is attribute in the header). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "npad"; token.key_prefix = "--"; token.label = "Padding"; token.help = "Number of times padding "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xysize"; token.key_prefix = "--"; token.label = "X,Y-dimension"; token.help = "Expected size in xy-plane. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "zsize"; token.key_prefix = "--"; token.label = "Z-dimension"; token.help = "Expected size in z. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "smearstep"; token.key_prefix = "--"; token.label = "Smear step"; token.help = "Rotational smear step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "interpolation_method"; token.key_prefix = "--"; token.label = "Interpolation method"; token.help = "Interpolation methods: nearest neighbor (4nn), or trilinear interpolation (tril). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4nn"; token.restore = [['4nn'], ['4nn']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "niter"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "NNumber of iterations for iterative reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10"; token.restore = [['10'], ['10']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "upweighted"; token.key_prefix = "--"; token.label = "Upweight"; token.help = "Apply background noise. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "compensate"; token.key_prefix = "--"; token.label = "Compensate"; token.help = "Compensate in reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk_id"; token.key_prefix = "--"; token.label = "Chunk ID"; token.help = "Reconstruct both odd and even groups of particles. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_window_size"; token.key_prefix = "--"; token.label = "Target window size"; token.help = "Size of the targeted reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_sort3d"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_signalsubtract"; sxcmd.subname = "avgfilt"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Average and Filter"; sxcmd.short_info = "Average and low-pass filter a map for segmentation."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "avol1"; token.key_prefix = "--"; token.label = "Map #1 to average"; token.help = "First map to average. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) - token = SXcmd_token(); token.key_base = "avol2"; token.key_prefix = "--"; token.label = "Map #2 to average"; token.help = "Second map to average. If not provided, first map will be used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "filtrad"; token.key_prefix = "--"; token.label = "Filter radius"; token.help = "Low-pass filter radius. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size"; token.help = "Pixel size in Angstroms. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_signalsubtract"; sxcmd.subname = "sp_mask"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Generate and Apply Mask"; sxcmd.short_info = "Make a soft mask of the region to be excluded."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "map2mask"; token.key_prefix = "--"; token.label = "Map to mask"; token.help = "Map from which a mask will be generated. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) - token = SXcmd_token(); token.key_base = "fullmap"; token.key_prefix = "--"; token.label = "Full map"; token.help = "Map which will be multiplied by the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mapthresh"; token.key_prefix = "--"; token.label = "Map threshold"; token.help = "Full map will be initially binarized at this threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_signalsubtract"; sxcmd.subname = "projsubtract"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Project and Subtract"; sxcmd.short_info = "Compute re-projections of map to be subtracted, and subtract them from the original images."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "origparts"; token.key_prefix = "--"; token.label = "Particle stack"; token.help = "Original particle stack before signal subtraction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "map2subtract"; token.key_prefix = "--"; token.label = "Map to subtract"; token.help = "Map whose projections will be subtracted from the original images. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "projparams"; token.key_prefix = "--"; token.label = "Projection parameters"; token.help = "Angles and shifts, from Meridien. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nmontage"; token.key_prefix = "--"; token.label = "Number of examples"; token.help = "This number of original, projections, and subtracted images will be written to disk. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "inmem"; token.key_prefix = "--"; token.label = "In memory?"; token.help = "Flag to store projections in memory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "saveprojs"; token.key_prefix = "--"; token.label = "Save projections?"; token.help = "Flag to save intermediate projections. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "stats"; token.key_prefix = "--"; token.label = "Save stats?"; token.help = "Flag to save normalization statistics. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Skip normalization?"; token.help = "Flag to skip normalization. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "stack"; sxcmd.subset_config = ""; sxcmd.label = "Compute 3D Reconstruction"; sxcmd.short_info = "Compute a 3D reconstruction using refinement iteration used for signal-subtraction."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Particle stack to use for reconstruction (i.e., after signal-subtraction)."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Meridien Directory"; token.help = "This directory must exist. In this mode, information is read from files in this directory. GUI will ask if you really want to continue; answer Yes."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "do_final"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voldir"; token.key_prefix = "--"; token.label = "Output Reconstruction Directory"; token.help = "Directory in which the output reconstructions will be written."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_signalsubtract"; sxcmd.subname = "centershift"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Center Map"; sxcmd.short_info = "Center map of remaining density."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "cvol1"; token.key_prefix = "--"; token.label = "Center map #1"; token.help = "First map to average and center. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) - token = SXcmd_token(); token.key_base = "cvol2"; token.key_prefix = "--"; token.label = "Center map #2"; token.help = "Second map to average and center. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) - token = SXcmd_token(); token.key_base = "shiftparams"; token.key_prefix = "--"; token.label = "Shift parameters"; token.help = "Meridien parameters to combine with centering parameters. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) - token = SXcmd_token(); token.key_base = "diffimgs"; token.key_prefix = "--"; token.label = "Subtracted images"; token.help = "Images from signal subtraction to reconstruct. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volradius"; token.key_prefix = "--"; token.label = "Structure radius"; token.help = "Radius to use for centering reconstruction. If the structure is not globular, try the shortest dimension. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size"; token.help = "Pixel size in Angstroms. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_meridien"; sxcmd.subname = ""; sxcmd.mode = "local_refinement"; sxcmd.subset_config = "stack"; sxcmd.label = "Local Refinement from Stack"; sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "local_refinement"; token.key_prefix = "--"; token.label = "Perform local refinement"; token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "inires"; token.key_prefix = "--"; token.label = "Starting resolution [A]"; token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [[-1.0], [-1.0]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Initial angular sampling step [Degrees]"; token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask3D"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xr"; token.key_prefix = "--"; token.label = "Search range [Pixels]"; token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5.0"; token.restore = [['5.0'], ['5.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ts"; token.key_prefix = "--"; token.label = "Search step size [Pixels]"; token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "an"; token.key_prefix = "--"; token.label = "Angular neighborhood"; token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shake"; token.key_prefix = "--"; token.label = "Shake"; token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "small_memory"; token.key_prefix = "--"; token.label = "Keep data in memory"; token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ccfpercentage"; token.key_prefix = "--"; token.label = "Correlation peaks to be included [%]"; token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = "99.9"; token.restore = [['99.9'], ['10']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nonorm"; token.key_prefix = "--"; token.label = "Apply image norm correction"; token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "function"; token.key_prefix = "--"; token.label = "Reference preparation function"; token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "do_volume_mask"; token.restore = [['do_volume_mask'], ['do_volume_mask']]; token.type = "user_func"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_subtract"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_locres"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Local Resolution"; sxcmd.short_info = "Compute local resolution of a map."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "First half-map"; token.help = "A sub-map computed from about half of input projection data. In case of quasi-independent half-refinements, it has to one of the two generated structures. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Second half-map"; token.help = "A sub-map computed from about half of input projection data. In case of quasi-independent half-refinements, it has to one of the two generated structures. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maskfile"; token.key_prefix = ""; token.label = "3D mask"; token.help = "Defines the region for which local resolution will be computed. It is advisable to eliminate irrelevant regions surrounding the structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Each voxel contains the associated resolution. It is expressed in absolute frequency units. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_continue"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix for output files. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "localres"; token.restore = [['localres'], ['localres']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Mask radius [Pixels]"; token.help = "In case no mask is provided, a hard sphere of this radius will be used. By default, radius = box_size/2 - (--wn). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['maskfile', 'none', 'False']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "wn"; token.key_prefix = "--"; token.label = "Window size [Pixels]"; token.help = "Size of window within which local real-space CCC (equivalent to FSC) is computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "7"; token.restore = [['7'], ['7']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Fourier shell step size [Pixels]"; token.help = "Values larger than 1.0 increase the speed and stability of the local resolution map, but decrease its reciprocal space resolvability. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cutoff"; token.key_prefix = "--"; token.label = "Local resolution criterion"; token.help = "Specify the resolution cut-off of the local resolution map. The map will contain, for each voxel, the value of spatical frequency at which local resolution at this voxel dropped below the specified cut-off level. Low values (say 0.14) result in a noisy and tus difficult to interpret local resolution map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.143"; token.restore = [['0.143'], ['0.143']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fsc"; token.key_prefix = "--"; token.label = "FSC output file"; token.help = "Contains the overall FSC curve computed by rotational averaging of local resolution values. It is truncated to --res_overall. By default, the program does not save the FSC curve. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "no curve"; token.restore = [['no curve'], ['no curve']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "out_ang_res"; token.key_prefix = "--"; token.label = "Save Angstrom local resolution"; token.help = "Additionally creates a local resolution file in Angstroms. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size of half-maps [A]"; token.help = "Effective only with --out_ang_res options. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['out_ang_res', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('out_ang_res', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "res_overall"; token.key_prefix = "--"; token.label = "Overall resolution [1/Pixel]"; token.help = "Specify overall (or global) resolution in absolute frequency (>=0.0 and <=0.5) for calibration of the average local resolution. Use the absolute frequency corresponding to the standard FSC resolution estimation. See Description section in the wiki page for details. By default, the program will not calibrate the average local resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "abs_freq"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_filterlocal"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Local Filter"; sxcmd.short_info = "Locally filter maps according to the local resolution determined by sp_locres."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input volume"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "locres_volume"; token.key_prefix = ""; token.label = "Local resolution file"; token.help = "Path to volume file containing the local resolution estimate produced by sp_locres. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maskfile"; token.key_prefix = ""; token.label = "3D mask"; token.help = "Defines the region where the local filtering should be applied. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputfile"; token.key_prefix = ""; token.label = "Output volume"; token.help = "Path to output volume file contained locally-filtered 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Mask radius [Pixels]"; token.help = "In case no mask is provided, a hard sphere will be used. Use radius of the particle. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "falloff"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "The program uses a tangent low-pass filter. Specify with absolute frequency. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sxresolution"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compute mFSC"; sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "firstvolume"; token.key_prefix = ""; token.label = "Volume #1"; token.help = "First unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "secondvolume"; token.key_prefix = ""; token.label = "Volume #2"; token.help = "Second unfiltered half-map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maskfile"; token.key_prefix = ""; token.label = "3D mask"; token.help = "Defines the region within which FSCM will be computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputdir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where output files will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Mask radius"; token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) - token = SXcmd_token(); token.key_base = "wn"; token.key_prefix = "--"; token.label = "Window size"; token.help = "Size of window within which local real-space FSC is computed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "15"; token.restore = [['15'], ['15']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "local_fsc"; token.key_prefix = "--"; token.label = "Compute local resolution"; token.help = "Set to 1 to compute local resolution volume. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0', '1'], ['0', '1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sigmag"; token.key_prefix = "--"; token.label = "Sigma of Gaussian window"; token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Shell step"; token.help = "Shell step in Fourier size in pixels (integer). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "lfi"; token.key_prefix = "--"; token.label = "Inner radius"; token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hfi"; token.key_prefix = "--"; token.label = "Outer radius"; token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "significance"; token.key_prefix = "--"; token.label = "Significance level"; token.help = "Significance level for the upper confidence interval "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.99"; token.restore = [['0.99'], ['0.99']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndf_reduce"; token.key_prefix = "--"; token.label = "Number of asymmetric units"; token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cutoff"; token.key_prefix = "--"; token.label = "FSC criterion"; token.help = "Resolution cut-off for FSCM confidence interval. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.143"; token.restore = [['0.143'], ['0.143']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nthreads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "Number of threads (mainly for 3D FFT). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4"; token.restore = [['4'], ['4']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_localres"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_unblur"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Unblur cisTEM"; sxcmd.short_info = "Align frames of micrograph movies with Unblur."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "unblur_path"; token.key_prefix = ""; token.label = "Unblur executable path"; token.help = "Specify the file path of Unblur executable. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input movie path pattern"; token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_file"; token.key_prefix = "--"; token.label = "Movie selection file"; token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrographs. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "bin_factor"; token.key_prefix = "--"; token.label = "Bin factor"; token.help = "Output bin factor. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "exposure_per_frame"; token.key_prefix = "--"; token.label = "Per frame exposure [e/A^2]"; token.help = "The electron dose per frame in e/A^2. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "pre_exposure"; token.key_prefix = "--"; token.label = "Pre-exposure [e/A^2]"; token.help = "The electron does in e/A^2 used for exposure prior to imaging. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "additional_dose_unadjusted"; token.key_prefix = "--"; token.label = "Create unadjusted sums in addition"; token.help = "Run unblur twice to also create dose unadjusted sums. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "gain_file"; token.key_prefix = "--"; token.label = "Gain file"; token.help = "Gain file in case of gain uncorrected movies. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_dose_adjustment"; token.key_prefix = "--"; token.label = "Apply dose filter"; token.help = "Indicate if dose filter should be applied or not. By default, apply dose filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "min_shift_initial"; token.key_prefix = "--"; token.label = "Minimum shift for initial search [A]"; token.help = "Minimum shift for initial search [A] "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outer_radius"; token.key_prefix = "--"; token.label = "Outer radius shift limit [A]"; token.help = "Outer radius shift limit "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "20.0"; token.restore = [['20.0'], ['20.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "b_factor"; token.key_prefix = "--"; token.label = "Apply B-factor to images [A^2]"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1500.0"; token.restore = [['1500.0'], ['1500.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "half_width_vert"; token.key_prefix = "--"; token.label = "Vertical Fourier central mask size"; token.help = "The half-width of central vertical line of Fourier mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "half_width_hor"; token.key_prefix = "--"; token.label = "Horizontal Fourier central mask size"; token.help = "The half-width of central horizontal line of Fourier mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "termination"; token.key_prefix = "--"; token.label = "Termination shift threshold"; token.help = "Termination shift threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "max_iterations"; token.key_prefix = "--"; token.label = "Maximum iterations"; token.help = "Maximum iterations. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "20"; token.restore = [['20'], ['20']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dont_restore_noise_power"; token.key_prefix = "--"; token.label = "Restore noise power"; token.help = "Indicate if noise power should be restored after dose adjustment or not. By default, restore noise power. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_frame"; token.key_prefix = "--"; token.label = "First frame"; token.help = "First frame to use for sum. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "last_frame"; token.key_prefix = "--"; token.label = "Last frame"; token.help = "Last frame to use for sum. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "distortion_angle"; token.key_prefix = "--"; token.label = "Distortion Angle [deg]"; token.help = "Distortion Angle in degrees. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "major_scale"; token.key_prefix = "--"; token.label = "Major scale"; token.help = "Major scale. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "minor_scale"; token.key_prefix = "--"; token.label = "Minor scale"; token.help = "Minor scale. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_gui_unblur"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Drift Assessment"; sxcmd.short_info = "Assess micrographs based on drift estimation produced by Unblur."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_pipe"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "inputfile"; token.key_prefix = ""; token.label = "Shift files"; token.help = "A wild card (*) can be used to process multiple shift files. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_drift_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_shift_list_file"; token.key_prefix = ""; token.label = "Input shift list file"; token.help = "Extension of input shift list file must be '.txt'. If this is not provided, all files matched with the micrograph name pattern will be processed. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_drift_params"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_unblur_old"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Unblur 1.0.2 (Pre cisTEM)"; sxcmd.short_info = "Align frames of micrograph movies with Unblur & Summovie."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_alt"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "unblur_path"; token.key_prefix = ""; token.label = "Unblur executable path"; token.help = "Specify the file path of Unblur executable. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input movie path pattern"; token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "summovie_path"; token.key_prefix = "--"; token.label = "Summovie executable path"; token.help = "Specify the file path of Summovie executable. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Movie selection file"; token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nr_frames"; token.key_prefix = "--"; token.label = "Number of movie frames"; token.help = "The number of movie frames in each input micrograph. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. Will be ignored when --skip_dose_filter option is used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "exposure_per_frame"; token.key_prefix = "--"; token.label = "Per frame exposure [e/A^2]"; token.help = "The electron dose per frame in e/A^2. Will be ignored when --skip_dose_filter option is used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "pre_exposure"; token.key_prefix = "--"; token.label = "Pre-exposure [e/A^2]"; token.help = "The electron does in e/A^2 used for exposure prior to imaging. Will be ignored when --skip_dose_filter option is used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nr_threads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "The number of threads Unblur can use. The higher the faster, but it requires larger memory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "save_frames"; token.key_prefix = "--"; token.label = "Save aligned movie frames"; token.help = "Save aligned movie frames. This option slows down the process. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_dose_filter"; token.key_prefix = "--"; token.label = "Apply dose filter"; token.help = "Indicate if dose filter should be applied or not. With this option, --voltage, --exposure_per_frame, and --pre_exposure will be ignored. By default, apply dose filter. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "expert_mode"; token.key_prefix = "--"; token.label = "Use expert mode"; token.help = "Requires --initial_shift, --shift_radius, --b_factor, --fourier_vertical, --fourier_horizontal, --shift_threshold, --iterations, --dont_restore_noise, and --verbosity options. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift_initial"; token.key_prefix = "--"; token.label = "Minimum shift for initial search [A]"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "shift_radius"; token.key_prefix = "--"; token.label = "Outer radius shift limit [A]"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "200.0"; token.restore = [['200.0'], ['200.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "b_factor"; token.key_prefix = "--"; token.label = "Apply B-factor to images [A^2]"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "1500.0"; token.restore = [['1500.0'], ['1500.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "fourier_vertical"; token.key_prefix = "--"; token.label = "Vertical Fourier central mask size"; token.help = "The half-width of central vertical line of Fourier mask. Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "fourier_horizontal"; token.key_prefix = "--"; token.label = "Horizontal Fourier central mask size"; token.help = "The half-width of central horizontal line of Fourier mask. Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "shift_threshold"; token.key_prefix = "--"; token.label = "Termination shift threshold"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "iterations"; token.key_prefix = "--"; token.label = "Maximum iterations"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = "10"; token.restore = [['10'], ['10']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "dont_restore_noise"; token.key_prefix = "--"; token.label = "Restore noise power"; token.help = "Indicate if noise power should be restored or not. By default, restore noise power. Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Effective only when --expert_mode option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_summovie"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Micrograph Movie Summation"; sxcmd.short_info = "Sum micrograph movies with Summovie."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "summovie_path"; token.key_prefix = ""; token.label = "Summovie executable path"; token.help = "Specify the file path of Summovie executable. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input movie path pattern"; token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_shift_pattern"; token.key_prefix = ""; token.label = "Input drift shift path pattern"; token.help = "Specify path pattern of input drift shift parameters files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and shift file. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_drift_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Movie selection file"; token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nr_frames"; token.key_prefix = "--"; token.label = "Number of movie frames"; token.help = "The number of movie frames in each input micrograph. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first"; token.key_prefix = "--"; token.label = "First movie frame"; token.help = "First movie frame for summing. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "last"; token.key_prefix = "--"; token.label = "Last movie frame"; token.help = "Last movie frame for summing. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nr_threads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "The number of threads Summovie can use. The higher the faster, but it requires larger memory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apply_dose_filter"; token.key_prefix = "--"; token.label = "Apply dose filter"; token.help = "Requires --voltage, --exposure_per_frame, and --pre_exposure options. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "exposure_per_frame"; token.key_prefix = "--"; token.label = "Per frame exposure [e/A^2]"; token.help = "The electron dose per frame in e/A^2. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "pre_exposure"; token.key_prefix = "--"; token.label = "Pre-exposure [e/A^2]"; token.help = "The electron does in e/A^2 used for exposure prior to imaging. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "dont_restore_noise"; token.key_prefix = "--"; token.label = "Restore noise power"; token.help = "Indicate if noise power should be restored or not. By default, restore noise power. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "organize_micrographs"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Organize Micrographs/Movies"; sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "source_micrograph_pattern"; token.key_prefix = ""; token.label = "Source micrograph/movies path pattern"; token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Micrograph/Movie selection file"; token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "select_mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "destination_directory"; token.key_prefix = ""; token.label = "Destination directory"; token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "reverse"; token.key_prefix = "--"; token.label = "Reverse operation"; token.help = "Move back micrographs/movies from the destination directory to the source directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "transphire"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "TranSPHIRE GUI"; sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_movie"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_batch"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Batch Pipeline Execution"; sxcmd.short_info = "Run jobs that wait with the execution on each other."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "submission_command"; token.key_prefix = ""; token.label = "Submission command"; token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_run_dir"; token.key_prefix = ""; token.label = "Pipeline directory"; token.help = "Directory containin the pipeline submission files "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "hold_flag"; token.key_prefix = "--"; token.label = "Hold flag"; token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first_hold_number"; token.key_prefix = "--"; token.label = "First hold number"; token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2display"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Display Data"; sxcmd.short_info = "Displays images, volumes, or 1D plots."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "input_data_list"; token.key_prefix = ""; token.label = "Input files"; token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "displayable_list"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "singleimage"; token.key_prefix = "--"; token.label = "Single image view"; token.help = "Display a stack one image at a time. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fullrange"; token.key_prefix = "--"; token.label = "Use full range of pixel values"; token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbose"; token.help = "Accepted values 0-9. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pdb2em"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "PDB File Conversion"; sxcmd.short_info = "Converts an atomic model stored in a PDB file into a simulated electron density map."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_pdb"; token.key_prefix = ""; token.label = "Input PDB file"; token.help = "Starting atomic coordinates. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "pdb"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_hdf"; token.key_prefix = ""; token.label = "Output map"; token.help = "Specify file path for output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size of output map [A]"; token.help = "Pixel size of the output map [A]. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box"; token.key_prefix = "--"; token.label = "Output box size [Voxels]"; token.help = "Specify string of a single value (e.g. '256') to get a cubic box. Alternatively, use 'x,y,z' format to specify demensions of x,y,z-axis (e.g. '128,64,256'). If not given, the program will find the minimum box size fitting the structure. Be aware that this will most likely result in a rectangular box. Note that GUI does not support the default mode. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "het"; token.key_prefix = "--"; token.label = "Include hetero atoms"; token.help = "Otherwise, the HETATM entries in the PDB file are ignored. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chains"; token.key_prefix = "--"; token.label = "Chain identifiers"; token.help = "A string list of chain identifiers to include (e.g. 'ABEFG'). By default, all chains will be included. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "center"; token.key_prefix = "--"; token.label = "Center model at the origin"; token.help = "Specifies whether the atomic model should be moved to the origin before generating density map. Available options are: 'c' - Use the geometrical center of atoms; 'a' - Use the center of mass (recommended); 'x,y,z' - Vector to be subtracted from all PDB coordinates. 'n' - No centering, in which case (0,0,0) in the PDB space will map to the center of the EM volume. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "a"; token.restore = [['a'], ['a']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "O"; token.key_prefix = "--"; token.label = "Apply additional rotation"; token.help = "This can be used to modify the orientation of the atomic model by using O system of coordinates. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "tr0"; token.key_prefix = "--"; token.label = "Rotational matrix file"; token.help = "This file must contain the 3x4 transformation matrix to be applied to the PDB coordinates after centering. The translation vector (last column of the matrix) must be specified in Angstrom. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "rot_matrix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "set_apix_value"; token.key_prefix = "--"; token.label = "Set header pixel size"; token.help = "Set pixel size in header of the ouput map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "quiet"; token.key_prefix = "--"; token.label = "Silent mode"; token.help = "Does not print any information to the monitor. Verbose is the default. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_relion2sphire"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "RELION to SPHIRE Conversion"; sxcmd.short_info = "Create several types of parameter text files and per-micrograph virtual stacks of particle images in bdb format from parameters stored in a RELION STAR file"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_star_file"; token.key_prefix = ""; token.label = "Input RELION STAR file"; token.help = "Specify a STAR file generated by RELION. The file should contain parameters related to Micrographs, CTF Estimation, Particle Extraction, 3D Alignment, or/and Random Subset. Entries for Micrographs category are required. If some entries associated with CTF Estimation, Particle Extraction, 3D Alignment, or/and Random Subset are missing, then the script does not produced the related output file(s). "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_relion_star"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "All the results will be written in here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "relion_project_dir"; token.key_prefix = "--"; token.label = "RELION project directory"; token.help = "Path to RELION project directory associated with the RELION STAR file. By default, the program assume the current directory is the RELION project directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "star_section"; token.key_prefix = "--"; token.label = "Section title in STAR file"; token.help = "The section title in the RELION star file where the data should be extracted. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "data_particles"; token.restore = [['data_particles'], ['data_particles']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sphire"; token.restore = [['sphire'], ['sphire']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Box size"; token.help = "Box size for particle extraction. It also controls the saved coordinates file format. If the given value is > 0, store the eman1 format. coordinate file. The coordinates of eman1 format is particle box corner associated with this box size. The coordinates of SPHIRE format is particle center. By default, use SPHIRE format. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "do_not_create_stack"; token.key_prefix = "--"; token.label = "Skip virtual stack creation"; token.help = "Create per-micrograph virtual stacks without the actual particle meta information in BDB format. By default, the program does generate the stack of particle meta information. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_sphire2relion"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "SPHIRE to RELION Conversion"; sxcmd.short_info = "Convert SPHIRE parameters to RELION."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output directory containing the output star file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "relion_project_dir"; token.key_prefix = "--"; token.label = "Relion project directory"; token.help = "Relion project directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "."; token.restore = [['.'], ['.']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_name"; token.key_prefix = "--"; token.label = "Output star file name"; token.help = "Output star file name. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sphire2relion.star"; token.restore = [['sphire2relion.star'], ['sphire2relion.star']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_stack"; token.key_prefix = "--"; token.label = "Particle stack"; token.help = "Particle stack in bdb or hdf format. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "partres_file"; token.key_prefix = "--"; token.label = "Partres file"; token.help = "Partres file containing the CTF information from the data set. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_2d_file"; token.key_prefix = "--"; token.label = "2D params file"; token.help = "2D alignment parameters. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "params_3d_file"; token.key_prefix = "--"; token.label = "3D params file"; token.help = "3D projection parameters. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_2d_file', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('params_2d_file', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "params_3d_index_file"; token.key_prefix = "--"; token.label = "3D params index file"; token.help = "Index file for the 3d params. Used to find the associated particle stack entry in the params file. In the meridien directories, this file is either called chunk or index."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "params_3d_chunk_file_0"; token.key_prefix = "--"; token.label = "First 3D params chunk file"; token.help = "First chunk file for the 3d params. Used to extract the _rlnRandomSubset information. In the meridien directories, this file is called chunk. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "params_3d_chunk_file_1"; token.key_prefix = "--"; token.label = "Second 3D params chunk file"; token.help = "Second chunk file for the 3d params. Used to extract the _rlnRandomSubset information. In the meridien directories, this file is called chunk. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "force"; token.key_prefix = "--"; token.label = "Force"; token.help = "Overwrite existing star file. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Include particle list"; token.help = "List of particles to include. Requires --particle_stack. Cannot be used together with --exlist. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'None', 'True'], ['exlist', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'None', 'True']); sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'None', 'False']) - token = SXcmd_token(); token.key_base = "exlist"; token.key_prefix = "--"; token.label = "Exclude particle list"; token.help = "List of particles to exclude. Requires --particle_stack. Cannot be used together with --list. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['particle_stack', 'None', 'True'], ['list', 'None', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'None', 'True']); sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'None', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_compare2d"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compare 2D images"; sxcmd.short_info = "Find best match between two sets of 2D images."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "image_stack_1"; token.key_prefix = ""; token.label = "Input stack #1"; token.help = "To each imagine in this stack, all of the images in the second input stack will be compared. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "image_stack_2"; token.key_prefix = ""; token.label = "Input stack #2"; token.help = "Each image from this stack will be aligned to each image from the first input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where output files will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outterradius"; token.key_prefix = "--"; token.label = "Outer radius"; token.help = "Outer radius in pixels. If not specified, the maximum allowed from the image dimension and maximum shift will be used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "normalize"; token.key_prefix = "--"; token.label = "Normalization mode"; token.help = "Methods for displaying the images from the two inputs stacks. If both comes from the same source, uses 'None'. Other options: 'minmax' (sets the minimum and maximum for each image to constants), 'rops' (sets 1D rotational power spectra equal to each other), and 'sigmaone' (sets the average to 0 and sigma to 1). "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None', 'minmax', 'rops', 'sigmaone'], ['None', 'minmax', 'rops', 'sigmaone']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "maxshift"; token.key_prefix = "--"; token.label = "Maximum shift"; token.help = "Maximum shift allowed during alignment. Alignment will be slowed significantly as the maximum shift increases. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ringstep"; token.key_prefix = "--"; token.label = "Ring step"; token.help = "Alignments will be computed at this radial increment, in pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbosity"; token.key_prefix = "--"; token.label = "Verbosity level"; token.help = "Controls how much information will be written to the screen, from 0..2. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_proj_compare"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Compare Re-projections"; sxcmd.short_info = "Compare re-projections to class averages."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Set of 2D images to be compared, i.e., class averages. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input volume"; token.help = "Reconstruction for which re-projections will be computed. In RVIPER, this file is of the form main003/run002/rotated_volume.hdf. This volume must have the same dimensions as the input images. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outdir"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Directory where outputs will be written. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mode"; token.key_prefix = "--"; token.label = "Comparison method"; token.help = "Choices are: viper, projmatch, and meridien. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "projmatch"; token.restore = [['projmatch', 'viper', 'meridien'], ['projmatch', 'viper', 'meridien']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "classangles"; token.key_prefix = "--"; token.label = "VIPER - Projection parameter file"; token.help = "Parameter file containing projection angles. Not required if the projection parameters are stored in the header of the input images, which for ISAC2 is generally not the case. In RVIPER, this file is of the form main003/run002/rotated_reduced_params.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) - token = SXcmd_token(); token.key_base = "classselect"; token.key_prefix = "--"; token.label = "VIPER - Image selection file"; token.help = "Input selection containing list of images to be included from the input stack. For instance, RVIPER, if it finds a stable solution, may exclude some images, and thus their projection angles will be excluded from the parameters file. The file containing the list of included images will have a name like main003/index_keep_image.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "ProjMatch - Sampling angle"; token.help = "Angular-sampling for reference projections. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "7.5"; token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], ['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "ProjMatch - Symmetry"; token.help = "To limit angular projections. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "partangles"; token.key_prefix = "--"; token.label = "MERIDIEN - Alignment parameter file"; token.help = "Input refinement parameter file, e.g., Refine3D/final_params_037.txt. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "params_proj_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "partselect"; token.key_prefix = "--"; token.label = "MERIDIEN - Particle selection file"; token.help = "Input substack selection file if particles removed before refinement, e.g., Substack/isac_substack_particle_id_list.txt. This file is used to map the particle number before classification to particle number in refinement. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "outliers"; token.key_prefix = "--"; token.label = "MERIDIEN - Outlier angle"; token.help = "Particles differing from average Euler angle by more than this threshold (in degrees) will be excluded from average calculation, by default keeps all. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "prjmethod"; token.key_prefix = "--"; token.label = "Interpolation method"; token.help = "Valid choices are trilinear, gridding, and nn. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "trilinear"; token.restore = [['trilinear', 'gridding', 'nn'], ['trilinear', 'gridding', 'nn']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "display"; token.key_prefix = "--"; token.label = "e2display"; token.help = "Automatically pops up a window with the output montage. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "matchshift"; token.key_prefix = "--"; token.label = "ProjMatch - Maximum shift"; token.help = "Maximum shift to allow during translation alignment, pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "matchrad"; token.key_prefix = "--"; token.label = "ProjMatch - Outer radius"; token.help = "Outer alignment radius, defaults to automatically-determined. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "matchstep"; token.key_prefix = "--"; token.label = "ProjMatch - Radius step size"; token.help = "Alignment radius step size. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) - token = SXcmd_token(); token.key_base = "refinerad"; token.key_prefix = "--"; token.label = "MERIDIEN - Outer radius"; token.help = "Outer alignment radius, defaults to automatically-determined. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "refineshift"; token.key_prefix = "--"; token.label = "MERIDIEN - Maximum shift"; token.help = "Maximum shift to allow during translation alignment, pixels. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "refinestep"; token.key_prefix = "--"; token.label = "MERIDIEN - Radius step size"; token.help = "Alignment radius step size. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - token = SXcmd_token(); token.key_base = "align"; token.key_prefix = "--"; token.label = "MERIDIEN - Alignment method"; token.help = "Valid choices are apsh and scf. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; token.default = "apsh"; token.restore = [['apsh', 'scf'], ['apsh', 'scf']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "moon_eliminator"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Volume Adjustment"; sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume_path"; token.key_prefix = ""; token.label = "Input volume path"; token.help = "Path to input volume file containing the 3D density map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Output pixel size [A]"; token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "use_density_threshold"; token.key_prefix = "--"; token.label = "Use ad-hoc density threshold"; token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "moon_distance"; token.key_prefix = "--"; token.label = "Distance to the nearest moon [Pixels]"; token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.0"; token.restore = [['3.0'], ['3.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resample_ratio"; token.key_prefix = "--"; token.label = "Resample ratio"; token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "'1.0'"; token.restore = [["'1.0'"], ["'1.0'"]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Output box size [Pixels]"; token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "invert_handedness"; token.key_prefix = "--"; token.label = "Invert handedness"; token.help = "Invert the handedness of the 3D map. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter resolution [A]"; token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_path_2nd"; token.key_prefix = ""; token.label = "Second input volume path"; token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1.0"; token.restore = [['-1.0'], ['-1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "outputs_root"; token.key_prefix = "--"; token.label = "Root name of outputs"; token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol3d"; token.restore = [['vol3d'], ['vol3d']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resampled_shift3d"; token.key_prefix = "--"; token.label = "Providing resampled 3D shifts"; token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_x"; token.key_prefix = "--"; token.label = "3D x-shift [Pixels]"; token.help = "3D x-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_y"; token.key_prefix = "--"; token.label = "3D y-shift [Pixels]"; token.help = "3D y-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "shift3d_z"; token.key_prefix = "--"; token.label = "3D z-shift [Pixels]"; token.help = "3D z-shift value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.1"; token.restore = [['0.1'], ['0.1']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "debug"; token.key_prefix = "--"; token.label = "Run with debug mode"; token.help = "Mainly for developers. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_mask"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Masking"; sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input image"; token.help = "Path to the 2D image or 3D Volume "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output direcory path "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "Output prefix"; token.help = "Prefix of the produced files "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "sp_mask"; token.restore = [['sp_mask'], ['sp_mask']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "overwrite"; token.key_prefix = "--"; token.label = "Overwrite outputs"; token.help = "Overwrite the output mask in case it exists already. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A/px]"; token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "allow_disconnected"; token.key_prefix = "--"; token.label = "Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fill_mask"; token.key_prefix = "--"; token.label = "Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nerosion"; token.key_prefix = "--"; token.label = "Number of erosions"; token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "do_old"; token.key_prefix = "--"; token.label = "Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "low_pass_filter_resolution"; token.key_prefix = "--"; token.label = "Low pass filter resolution [A]"; token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "low_pass_filter_falloff"; token.key_prefix = "--"; token.label = "Low pass filter falloff [1/Pixel]"; token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "use_second_mask"; token.key_prefix = "--"; token.label = "Use a second mask"; token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [True]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "second_mask"; token.key_prefix = "--"; token.label = "Second mask path"; token.help = "Path to the input second mask used for masking the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask_shape', 'none', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "second_mask_shape"; token.key_prefix = "--"; token.label = "Second mask shape"; token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; token.default = "none"; token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "s_radius"; token.key_prefix = "--"; token.label = "Second - Radius of the mask"; token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nx"; token.key_prefix = "--"; token.label = "Second - X dimension of the mask"; token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_ny"; token.key_prefix = "--"; token.label = "Second - Y dimension of the mask"; token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_nz"; token.key_prefix = "--"; token.label = "Second - Z dimension of the mask"; token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) - token = SXcmd_token(); token.key_base = "s_pixel_size"; token.key_prefix = "--"; token.label = "Second - Pixel size [A/px]"; token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_use_mol_mass"; token.key_prefix = "--"; token.label = "Second - Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_mol_mass"; token.key_prefix = "--"; token.label = "Second - Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_threshold"; token.key_prefix = "--"; token.label = "Second - Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_nsigma"; token.key_prefix = "--"; token.label = "Second - Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) - token = SXcmd_token(); token.key_base = "s_ndilation"; token.key_prefix = "--"; token.label = "Second - Number of dilations"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_nerosion"; token.key_prefix = "--"; token.label = "Second - Number of erosions"; token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_width"; token.key_prefix = "--"; token.label = "Second - Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "main"; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_edge_type"; token.key_prefix = "--"; token.label = "Second - Soft-edge type"; token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_do_old"; token.key_prefix = "--"; token.label = "Second - Old behaviour"; token.help = "Restore the old masking behaviour, which is a bit less smooth. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "s_allow_disconnected"; token.key_prefix = "--"; token.label = "Second - Allow disconnected regions"; token.help = "Allow disconnected region in the mask. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "s_fill_mask"; token.key_prefix = "--"; token.label = "Second - Fill mask"; token.help = "Fills empty spaces inside a map. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "s_invert"; token.key_prefix = "--"; token.label = "Second - Invert masking"; token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "changesize"; sxcmd.subset_config = ""; sxcmd.label = "Change Size of Image or Volume"; sxcmd.short_info = "Change size of image or map (decimate or interpolate up). The process results in changed pixel and window sizes. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "changesize"; token.key_prefix = "--"; token.label = "Change size of image or map"; token.help = "Change size of image or map (decimate or interpolate up). The process results in changed pixel and window sizes. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_stack"; token.key_prefix = ""; token.label = "Input image or volume"; token.help = "Input image or volume."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data2d3d_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_stack"; token.key_prefix = ""; token.label = "Output resized image or volume"; token.help = "Resized (decimated or interpolated up) image or volume."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ratio"; token.key_prefix = "--"; token.label = "Ratio of new to old image size"; token.help = "If < 1, the pixel size will increase and image size decrease. if > 1, the other way round. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2proc3d"; sxcmd.subname = ""; sxcmd.mode = "clip"; sxcmd.subset_config = ""; sxcmd.label = "Window Volume"; sxcmd.short_info = "Window (pad or clip) volume to the specific dimensions. Specify 1, 3 or 6 arguments; '<x>[,<y>,<z>[,<xc>,<yc>,<zc>]]'. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "clip"; token.key_prefix = "--"; token.label = "Window to specified size [Pixels]"; token.help = "Window (pad or clip) volume to the specific dimensions. Specify 1, 3 or 6 arguments; '<x>[,<y>,<z>[,<xc>,<yc>,<zc>]]'. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume"; token.key_prefix = ""; token.label = "Input volume"; token.help = "Path to input volume file."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_file"; token.key_prefix = ""; token.label = "Output windowed volume"; token.help = "Path to output windowed (clipped/padded) volume file."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "angular_distribution"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Angular Distribution"; sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "File containing the 3D projection parameters "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_folder"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Output folder name "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "prefix"; token.key_prefix = "--"; token.label = "File prefix"; token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Box size "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "256"; token.restore = [['256'], ['256']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of the project "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "particle_radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Particle radius "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "120"; token.restore = [['120'], ['120']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Angular sampling step [Degrees]"; token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3.75"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "method"; token.key_prefix = "--"; token.label = "Distribution method"; token.help = "Method used to create the reference angles (S or P or M) "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = "advanced"; token.dependency_group = [['', '', '']]; token.default = "S"; token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "dpi"; token.key_prefix = "--"; token.label = "Plot DPI"; token.help = "Dpi for the legend plot "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "144"; token.restore = [['144'], ['144']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nth_percentile"; token.key_prefix = "--"; token.label = "Nth percentil"; token.help = "Use the value of the nth percentile of the radius distribution for normalization "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "99"; token.restore = [['99'], ['99']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "old"; token.key_prefix = "--"; token.label = "Use old"; token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_recons3d_n"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "3D Reconstruction"; sxcmd.short_info = "3D Reconstruction using nearest-neighbor interpolation."; sxcmd.mpi_support = True; sxcmd.mpi_add_flag = True; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "prj_stack"; token.key_prefix = ""; token.label = "Input stack"; token.help = "Stack of projections "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_volume"; token.key_prefix = ""; token.label = "Output volume"; token.help = "Output reconstructed volume file "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "sym"; token.key_prefix = "--"; token.label = "Symmetry"; token.help = "Symmetry. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "CTF"; token.key_prefix = "--"; token.label = "Apply CTF"; token.help = "Apply CTF correction. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Selection list"; token.help = "File with list of images to be used in the first column. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "verbose"; token.key_prefix = "--"; token.label = "Verbosity"; token.help = "Enter 0 for no verbosity, 1 for verbose output. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "begin"; token.key_prefix = ""; token.label = "First image"; token.help = "First image for reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "end"; token.key_prefix = ""; token.label = "Last image"; token.help = "Last image for reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = ""; token.label = "Image step"; token.help = "Increment used for image list. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "snr"; token.key_prefix = "--"; token.label = "SNR"; token.help = "Signal-to-Noise Ratio. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "group"; token.key_prefix = "--"; token.label = "Group number"; token.help = "Perform reconstruction using images for a given group number (group is attribute in the header). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "npad"; token.key_prefix = "--"; token.label = "Padding"; token.help = "Number of times padding "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "xysize"; token.key_prefix = "--"; token.label = "X,Y-dimension"; token.help = "Expected size in xy-plane. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "zsize"; token.key_prefix = "--"; token.label = "Z-dimension"; token.help = "Expected size in z. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "smearstep"; token.key_prefix = "--"; token.label = "Smear step"; token.help = "Rotational smear step. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "interpolation_method"; token.key_prefix = "--"; token.label = "Interpolation method"; token.help = "Interpolation methods: nearest neighbor (4nn), or trilinear interpolation (tril). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "4nn"; token.restore = [['4nn'], ['4nn']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "niter"; token.key_prefix = "--"; token.label = "Iteration number"; token.help = "NNumber of iterations for iterative reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "10"; token.restore = [['10'], ['10']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "upweighted"; token.key_prefix = "--"; token.label = "Upweight"; token.help = "Apply background noise. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "compensate"; token.key_prefix = "--"; token.label = "Compensate"; token.help = "Compensate in reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk_id"; token.key_prefix = "--"; token.label = "Chunk ID"; token.help = "Reconstruct both odd and even groups of particles. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_window_size"; token.key_prefix = "--"; token.label = "Target window size"; token.help = "Size of the targeted reconstruction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_cryolo_boxmanager"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "crYOLO - boxmanager"; sxcmd.short_info = "Displays boxfiles on images. Allows creation of new training data for crYOLO."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "cryolo_bm_path"; token.key_prefix = "--"; token.label = "crYOLO boxmanager executable"; token.help = "Path to crYOLO boxmanager executable "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "target_dir"; token.key_prefix = "--"; token.label = "Input image directory"; token.help = "Path to input images "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_dir"; token.key_prefix = "--"; token.label = "Annotation directory"; token.help = "Path to annotation data like .box or .star files "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "balance_angular_distribution"; sxcmd.subset_config = ""; sxcmd.label = "Balance Angular Distribution"; sxcmd.short_info = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "balance_angular_distribution"; token.key_prefix = "--"; token.label = "Balance Angular Distribution"; token.help = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_any_txt"; token.key_prefix = ""; token.label = "Projection parameters"; token.help = "Typically from MERIDIEN with a filename in the form of Refine3D/final_params_0##.txt"; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Output selection list"; token.help = "Text file with a list of retained particle images"; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "max_occupy"; token.key_prefix = "--"; token.label = "Maximum orientations per reference angle"; token.help = "Maximum number of particles per reference angle. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "angstep"; token.key_prefix = "--"; token.label = "Angular increment"; token.help = "Angular step of reference angles. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "15"; token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Point-group symmetry"; token.help = "angular step of reference angles, i.e., number of bins of angular histogram. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_process"; sxcmd.subname = ""; sxcmd.mode = "combinemaps"; sxcmd.subset_config = "single map"; sxcmd.label = "PostRefiner (Single Map)"; sxcmd.short_info = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "combinemaps"; token.key_prefix = "--"; token.label = "Post-refine single map"; token.help = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; token.group = "main"; token.is_required = True; token.is_locked = True; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_volume_pattern"; token.key_prefix = ""; token.label = "Input volume pattern"; token.help = "Specify path pattern of input single volumes with a wild card '*' or path to single volume file (without wild card '*'). Use the wild card to indicate the place of variable part of the file names. The path pattern must be enclosed by single quotes (') or double quotes (') (Note: sxgui.py automatically adds single quotes ('))."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_dir"; token.key_prefix = "--"; token.label = "Output directory"; token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size of input data. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "3D mask file"; token.help = "Path to user-provided mask. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "do_adaptive_mask"; token.key_prefix = "--"; token.label = "Apply adaptive mask"; token.help = "Program creates mask adaptively with given density threshold. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) - token = SXcmd_token(); token.key_base = "use_mol_mass"; token.key_prefix = "--"; token.label = "Use molecular mass"; token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool_ignore"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The estimated molecular mass of the target particle in kilodaltons. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "threshold"; token.key_prefix = "--"; token.label = "Binarization threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "-9999.0"; token.restore = [['-9999.0'], ['-9999.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "nsigma"; token.key_prefix = "--"; token.label = "Density standard deviation threshold"; token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], ['do_adaptive_mask', 'True', 'False']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "ndilation"; token.key_prefix = "--"; token.label = "Dilation width [Pixels]"; token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_width"; token.key_prefix = "--"; token.label = "Soft-edge width [Pixels]"; token.help = "The pixel width of transition area for soft-edged masking."; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "edge_type"; token.key_prefix = "--"; token.label = "Soft-edge type"; token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; token.default = "cosine"; token.restore = [['cosine'], ['cosine']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "do_approx"; token.key_prefix = "--"; token.label = "Approximate values"; token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) - token = SXcmd_token(); token.key_base = "mtf"; token.key_prefix = "--"; token.label = "MTF file"; token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mtf"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "B_enhance"; token.key_prefix = "--"; token.label = "B-factor enhancement"; token.help = "Non-zero positive value: program use provided B-factor [A^2] to enhance the map; -1.0: B-factor is not applied."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "fl"; token.key_prefix = "--"; token.label = "Low-pass filter frequency [A]"; token.help = "A value larger than 0.5: low-pass filter to the resolution in Angstrom; -1.0: no low-pass filter."; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "aa"; token.key_prefix = "--"; token.label = "Low-pass filter fall-off [1/Pixels]"; token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; token.default = "0.01"; token.restore = [['0.01'], ['0.01']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) - token = SXcmd_token(); token.key_base = "output"; token.key_prefix = "--"; token.label = "Output file name"; token.help = "File name of output final post-refined structure. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "vol_combined.hdf"; token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_summovie"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Micrograph Movie Summation"; sxcmd.short_info = "Sum micrograph movies with Summovie."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "summovie_path"; token.key_prefix = ""; token.label = "Summovie executable path"; token.help = "Specify the file path of Summovie executable. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_micrograph_pattern"; token.key_prefix = ""; token.label = "Input movie path pattern"; token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_shift_pattern"; token.key_prefix = ""; token.label = "Input drift shift path pattern"; token.help = "Specify path pattern of input drift shift parameters files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and shift file. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_drift_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = "--"; token.label = "Movie selection file"; token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Summovie executable.) "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nr_frames"; token.key_prefix = "--"; token.label = "Number of movie frames"; token.help = "The number of movie frames in each input micrograph. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "3"; token.restore = [['3'], ['3']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "first"; token.key_prefix = "--"; token.label = "First movie frame"; token.help = "First movie frame for summing. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "last"; token.key_prefix = "--"; token.label = "Last movie frame"; token.help = "Last movie frame for summing. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "pixel_size"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrographs. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "nr_threads"; token.key_prefix = "--"; token.label = "Number of threads"; token.help = "The number of threads Summovie can use. The higher the faster, but it requires larger memory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1"; token.restore = [['1'], ['1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apply_dose_filter"; token.key_prefix = "--"; token.label = "Apply dose filter"; token.help = "Requires --voltage, --exposure_per_frame, and --pre_exposure options. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "exposure_per_frame"; token.key_prefix = "--"; token.label = "Per frame exposure [e/A^2]"; token.help = "The electron dose per frame in e/A^2. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "2.0"; token.restore = [['2.0'], ['2.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "pre_exposure"; token.key_prefix = "--"; token.label = "Pre-exposure [e/A^2]"; token.help = "The electron does in e/A^2 used for exposure prior to imaging. Effective only when --apply_dose_filter option is used. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "dont_restore_noise"; token.key_prefix = "--"; token.label = "Restore noise power"; token.help = "Indicate if noise power should be restored or not. By default, restore noise power. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = True; token.restore = [[True], [True]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_header"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Header Operations"; sxcmd.short_info = "Perform operations on headers of hdf or bdb file."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "stack"; token.key_prefix = ""; token.label = "Input image stack"; token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params"; token.key_prefix = "--"; token.label = "Target parameters"; token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "import"; token.key_prefix = "--"; token.label = "Import parameters"; token.help = "Import parameters from file. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "export"; token.key_prefix = "--"; token.label = "Export parameters"; token.help = "Export parameters to file. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delete"; token.key_prefix = "--"; token.label = "Delete all"; token.help = "Delete all parameters. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "zero"; token.key_prefix = "--"; token.label = "Set to zero"; token.help = "Set all parameters to zero. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "one"; token.key_prefix = "--"; token.label = "Set to one"; token.help = "Set all parameters to one. This is not applicable to xform.align2d, xform.proj or xform.align3d, beccause they do not make sense. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "set"; token.key_prefix = "--"; token.label = "Set to constant"; token.help = "Set parameters to a specified constant value, other than 0.0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0"; token.restore = [['0.0'], ['0.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "consecutive"; token.key_prefix = "--"; token.label = "Set to consecutive"; token.help = "Set selected parameters to consecutive integers starting from 0. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "randomize"; token.key_prefix = "--"; token.label = "Set to random"; token.help = "Set all parameters to randomized value. This works only for xform.align2d, xform.proj and xform.align3d since there is little need to randomize the other parameters and it is also difficult to guess the random range beforehand. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rand_alpha"; token.key_prefix = "--"; token.label = "Set angles to random"; token.help = "Set all angles to random values. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "print"; token.key_prefix = "--"; token.label = "Print to screen"; token.help = "Print parameters to screen. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "backup"; token.key_prefix = "--"; token.label = "Backup all"; token.help = "Backup all parameters. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "restore"; token.key_prefix = "--"; token.label = "Restore all"; token.help = "Restore all parameters. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "suffix"; token.key_prefix = "--"; token.label = "Suffix for backup"; token.help = "Suffix for xform name in backup. This will be added to the name of a parameter or removed during restore. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "_backup"; token.restore = [['_backup'], ['_backup']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "e2bdb"; sxcmd.subname = ""; sxcmd.mode = "makevstack"; sxcmd.subset_config = ""; sxcmd.label = "Create Virtual Stack"; sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "makevstack"; token.key_prefix = "--"; token.label = "Output virtual image stack"; token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output_bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "input_bdb_stack_file"; token.key_prefix = ""; token.label = "Input BDB image stack"; token.help = "Specify path to input BDB stack file. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "list"; token.key_prefix = "--"; token.label = "Image selection file"; token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual bdb image stack from an existed stack or virtual stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) - token = SXcmd_token(); token.key_base = "exlist"; token.key_prefix = "--"; token.label = "Image exclusion file"; token.help = "Input exclusion text file containing a list of excluded image IDs (or indexes of the data subset) to create a new virtual bdb image stacks from an existed stack or virtual stack. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['step', '0,1', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) - token = SXcmd_token(); token.key_base = "step"; token.key_prefix = "--"; token.label = "Processes only subset"; token.help = "Specify <init>,<step>[,<max>]. Process only a subset of the input data. For example, 0,2 would process only the even numbered particles. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['exlist', 'none', 'False']]; token.default = "0,1"; token.restore = [['0,1'], ['0,1']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_pipe"; sxcmd.subname = "organize_micrographs"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Organize Micrographs/Movies"; sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "source_micrograph_pattern"; token.key_prefix = ""; token.label = "Source micrograph/movies path pattern"; token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "selection_list"; token.key_prefix = ""; token.label = "Micrograph/Movie selection file"; token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "select_mic_both"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "destination_directory"; token.key_prefix = ""; token.label = "Destination directory"; token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "reverse"; token.key_prefix = "--"; token.label = "Reverse operation"; token.help = "Move back micrographs/movies from the destination directory to the source directory. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "check_consistency"; token.key_prefix = "--"; token.label = "Check consistency of dataset"; token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "meridien"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Meridien)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "refinement_dir"; token.key_prefix = ""; token.label = "Meridien directory"; token.help = "Path to Meridien directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_ctf_refine"; sxcmd.subname = "manual"; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "CTF refine (Stack)"; sxcmd.short_info = "Refine the defocus per particle"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = True - token = SXcmd_token(); token.key_base = "path_to_input_stack"; token.key_prefix = ""; token.label = "Input stack path"; token.help = "Path to input stack. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "Folder to output files etc. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume_path"; token.key_prefix = ""; token.label = "Path to volume"; token.help = "Path to volume. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "params_file"; token.key_prefix = ""; token.label = "Params file"; token.help = "Path to params file "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mask"; token.key_prefix = "--"; token.label = "Path to mask"; token.help = "Path to mask used. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "range"; token.key_prefix = "--"; token.label = "Defocus search range [um]"; token.help = "Search range +- around the current defocus value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.15"; token.restore = [['0.15'], ['0.15']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "delta"; token.key_prefix = "--"; token.label = "Defocus search delta [um]"; token.help = "Finest search delta. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "0.0025"; token.restore = [['0.0025'], ['0.0025']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "resolution"; token.key_prefix = "--"; token.label = "Nominal resolution [A]"; token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "Pixel size in Angstroms. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; token.default = "None"; token.restore = [['None'], ['None']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) - token = SXcmd_token(); token.key_base = "number_part"; token.key_prefix = "--"; token.label = "Number of particles"; token.help = "Number of particles to process. Mainly for debugging. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "chunk"; token.key_prefix = "--"; token.label = "Path to chunk file"; token.help = "Path to chunk file "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "select_data2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "volume2"; token.key_prefix = "--"; token.label = "Path to second volume"; token.help = "Path to second half volume. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "sp_auto"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "Auto SPHIRE"; sxcmd.short_info = "Run SPHIRE up to 3D refinement in an automated manner"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False - token = SXcmd_token(); token.key_base = "output_directory"; token.key_prefix = ""; token.label = "Output directory"; token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; token.group = "main"; token.is_required = True; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = ""; token.restore = [[""], [""]]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "apix"; token.key_prefix = "--"; token.label = "Pixel size [A]"; token.help = "The pixel size of input micrographs. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "1.0"; token.restore = [['1.0'], ['1.0']]; token.type = "apix"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mol_mass"; token.key_prefix = "--"; token.label = "Molecular mass [kDa]"; token.help = "The molecular mass of the protein in kilo Dalton. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "250"; token.restore = [['250'], ['250']]; token.type = "mass"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "radius"; token.key_prefix = "--"; token.label = "Particle radius [Pixels]"; token.help = "Outer particle radius in pixels < int(boxsize/2)-1. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "80"; token.restore = [['80'], ['80']]; token.type = "radius"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "box_size"; token.key_prefix = "--"; token.label = "Particle box size [Pixels]"; token.help = "Particle box size. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "200"; token.restore = [['200'], ['200']]; token.type = "box"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "symmetry"; token.key_prefix = "--"; token.label = "Symmetry"; token.help = "Symmetry of the protein. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "c1"; token.restore = [['c1'], ['c1']]; token.type = "sym"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "voltage"; token.key_prefix = "--"; token.label = "Microscope voltage [kV]"; token.help = "The acceleration voltage of microscope used for imaging. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "300.0"; token.restore = [['300.0'], ['300.0']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "negative_stain"; token.key_prefix = "--"; token.label = "Is neg. stain data set"; token.help = "Check if the data set is collected via negative stain. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['phase_plate', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('phase_plate', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "phase_plate"; token.key_prefix = "--"; token.label = "Is VPP data set"; token.help = "Check if the data set is collected with a phase plate. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['negative_stain', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('negative_stain', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "fill_rviper_mask"; token.key_prefix = "--"; token.label = "Do not fill the mask for 3D refinement"; token.help = "Check if you do not want to fill the mask for the first 3D refinement. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mtf"; token.key_prefix = "--"; token.label = "MTF file"; token.help = "Path to the MTF file of the used detector. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mtf"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "memory_per_node"; token.key_prefix = "--"; token.label = "Memory per node [GB]"; token.help = "Available memory per node. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "-1"; token.restore = [['-1'], ['-1']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "unblur_path"; token.key_prefix = "--"; token.label = "Unblur executable"; token.help = "Path to the unblur executable. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "exe"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "unblur_mic_pattern"; token.key_prefix = "--"; token.label = "Unblur micrograph patten"; token.help = "Micrograph pattern containing the wildcard character *. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mic_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "unblur_exp_per_frame"; token.key_prefix = "--"; token.label = "Unblur exposure per frame [e/A^2]"; token.help = "Exposure per frame for dose adjustment. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "unblur_gain_file"; token.key_prefix = "--"; token.label = "Unblur gain file"; token.help = "Path to the gain file. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cter_cs"; token.key_prefix = "--"; token.label = "CTER spherical aberration (Cs) [mm]"; token.help = "Spherical aberration of the microscope. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; token.default = "2.7"; token.restore = [['2.7'], ['2.7']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_predict_path"; token.key_prefix = "--"; token.label = "CrYOLO predict path"; token.help = "Path to the CrYOLO precict executable. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "py"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_model_path"; token.key_prefix = "--"; token.label = "CrYOLO model path"; token.help = "Path to the CrYOLO model file. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_config_path"; token.key_prefix = "--"; token.label = "CrYOLO config path"; token.help = "Path to the CrYOLO config file. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_json"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_gpu"; token.key_prefix = "--"; token.label = "CrYOLO GPUs"; token.help = "Numbers of the GPUs to use seperated by commas. -1 is used for the CPU version. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "isac2_img_per_grp"; token.key_prefix = "--"; token.label = "ISAC2 images per group"; token.help = "Number of images per group. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; token.default = "100"; token.restore = [['100'], ['100']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_predict_path"; token.key_prefix = "--"; token.label = "Cinderella predict path"; token.help = "Path to the Cinderella executable. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_model_path"; token.key_prefix = "--"; token.label = "Cinderella model path"; token.help = "Path to trained Cinderella model. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_any_h5"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "mpi_procs"; token.key_prefix = "--"; token.label = "MPI processors"; token.help = "Number of processors you want to use for auto SPHIRE. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mpi_job_name"; token.key_prefix = "--"; token.label = "MPI job name"; token.help = "Name of the submission job. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "auto_sphire"; token.restore = [['auto_sphire'], ['auto_sphire']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mpi_submission_command"; token.key_prefix = "--"; token.label = "MPI Submission command"; token.help = "Submission command to execute the Auto SPHIRE job "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "none"; token.restore = [['none', 'sbatch', 'qsub'], ['none', 'sbatch', 'qsub']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "mpi_submission_template"; token.key_prefix = "--"; token.label = "MPI Submission script template"; token.help = "Template to submit the job to a queue. "; token.group = "main"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = "msgui_template.sh"; token.restore = [['msgui_template.sh'], ['msgui_template.sh']]; token.type = "params_any_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "skip_unblur"; token.key_prefix = "--"; token.label = "Skip UNBLUR"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "unblur_output_dir"; token.key_prefix = "--"; token.label = "UNBLUR output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "UNBLUR"; token.restore = [['UNBLUR'], ['UNBLUR']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "unblur_addition"; token.key_prefix = "--"; token.label = "UNBLUR addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_cter"; token.key_prefix = "--"; token.label = "Skip CTER"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cter_mic_pattern"; token.key_prefix = "--"; token.label = "CTER input pattern"; token.help = "Pattern of the cter input pattern. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_cter', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cter_window_size"; token.key_prefix = "--"; token.label = "CTER window size"; token.help = "Window size for the CTF estimation. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; token.default = "1024"; token.restore = [['1024'], ['1024']]; token.type = "ctfwin"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cter_output_dir"; token.key_prefix = "--"; token.label = "CTER output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; token.default = "CTER"; token.restore = [['CTER'], ['CTER']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cter_addition"; token.key_prefix = "--"; token.label = "CTER addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_cryolo"; token.key_prefix = "--"; token.label = "Skip CrYOLO"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cryolo_mic_path"; token.key_prefix = "--"; token.label = "CRYOLO micrograph path"; token.help = "Path of the cryolo input images. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_cryolo', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "dir"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_output_dir"; token.key_prefix = "--"; token.label = "CRYOLO output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "CRYOLO_PREDICT"; token.restore = [['CRYOLO_PREDICT'], ['CRYOLO_PREDICT']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cryolo_addition"; token.key_prefix = "--"; token.label = "CRYOLO addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_window"; token.key_prefix = "--"; token.label = "Skip WINDOW"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "window_box_pattern"; token.key_prefix = "--"; token.label = "WINDOW input box pattern"; token.help = "Pattern of the box files. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cryolo', 'True', 'False'], ['skip_window', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_coords_any"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "window_mic_pattern"; token.key_prefix = "--"; token.label = "WINDOW input micrograph pattern"; token.help = "Pattern of the input micrograph files. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_window', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "mic_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "window_partres"; token.key_prefix = "--"; token.label = "WINDOW partres file"; token.help = "Path to the partres file. In case of negative stain use the pixel size value. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cter', 'True', 'False'], ['skip_window', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "params_cter_txt"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "window_output_dir"; token.key_prefix = "--"; token.label = "WINDOW output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_window', 'False', 'False']]; token.default = "WINDOW"; token.restore = [['WINDOW'], ['WINDOW']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "window_addition"; token.key_prefix = "--"; token.label = "WINDOW addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_window', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_isac2"; token.key_prefix = "--"; token.label = "Skip ISAC2"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "isac2_input_stack"; token.key_prefix = "--"; token.label = "ISAC2 input stack"; token.help = "Stack used for ISAC2 "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_window', 'True', 'False'], ['skip_isac2', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "isac2_output_dir"; token.key_prefix = "--"; token.label = "ISAC2 output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; token.default = "ISAC"; token.restore = [['ISAC'], ['ISAC']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "isac2_addition"; token.key_prefix = "--"; token.label = "ISAC2 addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "substack_output_dir"; token.key_prefix = "--"; token.label = "ISAC2 substack output name"; token.help = "Name of the output directory for the ISAC substack. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; token.default = "SUBSTACK"; token.restore = [['SUBSTACK'], ['SUBSTACK']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_cinderella"; token.key_prefix = "--"; token.label = "Skip Cinderella"; token.help = "Skip automatic 2D class selection. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "cinderella_output_dir"; token.key_prefix = "--"; token.label = "Cinderella output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "AUTO2D"; token.restore = [['AUTO2D'], ['AUTO2D']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_input_stack"; token.key_prefix = "--"; token.label = "Cinderella input stack"; token.help = "Path to ISAC class stack "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_conf_thresh"; token.key_prefix = "--"; token.label = "Cinderella confidence threshold"; token.help = "Classes with a confidence higher as that threshold are classified as good. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "0.5"; token.restore = [['0.5'], ['0.5']]; token.type = "float"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_gpu"; token.key_prefix = "--"; token.label = "Cinderella GPU ID"; token.help = "ID of the GPU to run on. -1 will choose a GPU automatically. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "0"; token.restore = [['0'], ['0']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "cinderella_batch_size"; token.key_prefix = "--"; token.label = "Cinderella Batch size"; token.help = "Number of images in one batch during prediction. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; token.default = "32"; token.restore = [['32'], ['32']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_rviper"; token.key_prefix = "--"; token.label = "Skip RVIPER"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "rviper_use_final"; token.key_prefix = "--"; token.label = "RVIPER use final result"; token.help = "Whether to use the first volume of the first iteration or the last volume of the last iteration "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'True', 'False'], ['skip_rviper', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "rviper_input_stack"; token.key_prefix = "--"; token.label = "RVIPER input stack"; token.help = "Stack used for RVIPER "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_isac2', 'True', 'False'], ['skip_rviper', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data2d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']); sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "rviper_output_dir"; token.key_prefix = "--"; token.label = "RVIPER output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_rviper', 'False', 'False']]; token.default = "RVIPER"; token.restore = [['RVIPER'], ['RVIPER']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "rviper_addition"; token.key_prefix = "--"; token.label = "RVIPER Addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_rviper', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_adjust_rviper"; token.key_prefix = "--"; token.label = "Skip ADJUST_RVIPER"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "adjust_rviper_resample"; token.key_prefix = "--"; token.label = "ADJUST_RVIPER resample ratio"; token.help = "Resample ratio or ISAC directory "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False'], ['skip_isac2', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "adjust_rviper_output_dir"; token.key_prefix = "--"; token.label = "ADJUST_RVIPER output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False']]; token.default = "RVIPER_ADJUSTMENT"; token.restore = [['RVIPER_ADJUSTMENT'], ['RVIPER_ADJUSTMENT']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "adjust_rviper_addition"; token.key_prefix = "--"; token.label = "ADJUST_RVIPER addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_mask_rviper"; token.key_prefix = "--"; token.label = "Skip MASK_RVIPER"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_adjustment_rviper', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "mask_rviper_ndilation"; token.key_prefix = "--"; token.label = "MASK_RVIPER ndilation"; token.help = "Number of dilations. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], ['skip_adjustment_rviper', 'False', 'False']]; token.default = "5"; token.restore = [['5'], ['5']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "mask_rviper_soft_edge"; token.key_prefix = "--"; token.label = "MASK_RVIPER soft edge"; token.help = "Number of pixels for the soft edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], ['skip_adjustment_rviper', 'False', 'False']]; token.default = "10"; token.restore = [['10'], ['10']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "mask_rviper_output_dir"; token.key_prefix = "--"; token.label = "MASK_RVIPER output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], ['skip_adjustment_rviper', 'False', 'False']]; token.default = "RVIPER_MASK"; token.restore = [['RVIPER_MASK'], ['RVIPER_MASK']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "mask_rviper_addition"; token.key_prefix = "--"; token.label = "MASK_RVIPER addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], ['skip_adjustment_rviper', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_meridien"; token.key_prefix = "--"; token.label = "Skip MERIDIEN"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "meridien_input_volume"; token.key_prefix = "--"; token.label = "MERIDIEN input volume"; token.help = "Input volume path. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_adjust_rviper', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "meridien_input_stack"; token.key_prefix = "--"; token.label = "MERIDIEN input stack"; token.help = "Inpust particle stack. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_isac2', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "meridien_input_mask"; token.key_prefix = "--"; token.label = "MERIDIEN input mask"; token.help = "3D Mask file. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_mask_rviper', 'True', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "data3d_one"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'True', 'False']) - token = SXcmd_token(); token.key_base = "meridien_output_dir"; token.key_prefix = "--"; token.label = "MERIDIEN output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; token.default = "MERIDIEN"; token.restore = [['MERIDIEN'], ['MERIDIEN']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "meridien_addition"; token.key_prefix = "--"; token.label = "MERIDIEN addititions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_sharpening_meridien"; token.key_prefix = "--"; token.label = "Skip SHARPENING_MERIDIEN"; token.help = "Skip the movie alignment in case that you already have aligned movies. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "sharpening_meridien_ndilation"; token.key_prefix = "--"; token.label = "SHARPENING_MERIDIEN ndilation"; token.help = "Number of dilations. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], ['skip_meridien', 'False', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "sharpening_meridien_soft_edge"; token.key_prefix = "--"; token.label = "SHARPENING_MERIDIEN soft edge"; token.help = "Number of pixels for the soft edge. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], ['skip_meridien', 'False', 'False']]; token.default = "8"; token.restore = [['8'], ['8']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "sharpening_meridien_output_dir"; token.key_prefix = "--"; token.label = "SHARPENING_MERIDIEN output name"; token.help = "Name of the output directory. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], ['skip_meridien', 'False', 'False']]; token.default = "SHARPENING"; token.restore = [['SHARPENING'], ['SHARPENING']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "sharpening_meridien_addition"; token.key_prefix = "--"; token.label = "SHARPENING_MERIDIEN additions"; token.help = "Optional additional arguments. "; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], ['skip_meridien', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_restack"; token.key_prefix = "--"; token.label = "Skip RESTACKING"; token.help = "Skip restacking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "restack_output_dir"; token.key_prefix = "--"; token.label = "RESTACKING output name"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "RESTACK"; token.restore = [['RESTACK'], ['RESTACK']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_addition"; token.key_prefix = "--"; token.label = "RESTACKING additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_window_output_dir"; token.key_prefix = "--"; token.label = "RESTACKING_WINDOW output dir"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "RESTACK_WINDOW"; token.restore = [['RESTACK_WINDOW'], ['RESTACK_WINDOW']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_window_mic_pattern"; token.key_prefix = "--"; token.label = "RESTACKING_WINDOW mic pattern"; token.help = "Micrograph pattern for restacking."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_window_partres"; token.key_prefix = "--"; token.label = "RESTACKING_WINDOW partres file"; token.help = "Partres file"; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "bdb2d_stack"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_window_addition"; token.key_prefix = "--"; token.label = "RESTACKING_WINDOW additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_meridien_output_dir"; token.key_prefix = "--"; token.label = "RESTACKING_MERIDIEN output dir"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "RESTACK_MERIDIEN"; token.restore = [['RESTACK_MERIDIEN'], ['RESTACK_MERIDIEN']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_meridien_addition"; token.key_prefix = "--"; token.label = "RESTACKING_MERIDIEN additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_sharpening_ndilation"; token.key_prefix = "--"; token.label = "RESTACKING_SHARPENING ndilation"; token.help = "Number of dilations of the mask. 1 Dilation adds about 2 pixel to the binary volume."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_sharpening_soft_edge"; token.key_prefix = "--"; token.label = "RESTACKING_SHARPENING soft edge"; token.help = "Number of pixels for the soft edge."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "8"; token.restore = [['8'], ['8']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_sharpening_output_dir"; token.key_prefix = "--"; token.label = "RESTACKING_SHARPENING output dir"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "RESTACK_SHARPENING"; token.restore = [['RESTACK_SHARPENING'], ['RESTACK_SHARPENING']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "restack_sharpening_addition"; token.key_prefix = "--"; token.label = "RESTACKING_SHARPENING additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "skip_ctf_refine"; token.key_prefix = "--"; token.label = "Skip CTF_REFINE"; token.help = "Skip CTF refinement."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - token = SXcmd_token(); token.key_base = "ctf_refine_output_dir"; token.key_prefix = "--"; token.label = "CTF_REFINE output name"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "CTF_REFINE"; token.restore = [['CTF_REFINE'], ['CTF_REFINE']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_refine_addition"; token.key_prefix = "--"; token.label = "CTF_REFINE additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_meridien_output_dir"; token.key_prefix = "--"; token.label = "CTF_MERIDIEN output name"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "CTF_MERIDIEN"; token.restore = [['CTF_MERIDIEN'], ['CTF_MERIDIEN']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_meridien_addition"; token.key_prefix = "--"; token.label = "CTF_MERIDIEN additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_sharpening_ndilation"; token.key_prefix = "--"; token.label = "CTF_SHARPENING ndilation"; token.help = "Number of dilations of the mask. 1 Dilation adds about 2 pixel to the binary volume."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "2"; token.restore = [['2'], ['2']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_sharpening_soft_edge"; token.key_prefix = "--"; token.label = "CTF_SHARPENING soft edge"; token.help = "Number of pixels for the soft edge."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "8"; token.restore = [['8'], ['8']]; token.type = "int"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_sharpening_output_dir"; token.key_prefix = "--"; token.label = "CTF_SHARPENING output name"; token.help = "Restacking output directory."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "CTF_SHARPENING"; token.restore = [['CTF_SHARPENING'], ['CTF_SHARPENING']]; token.type = "output"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "ctf_sharpening_addition"; token.key_prefix = "--"; token.label = "CTF_SHARPENING additions"; token.help = "Additional parameters that are not part of the required ones."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], ['skip_ctf_refine', 'False', 'False']]; token.default = "none"; token.restore = [['none'], ['none']]; token.type = "string"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token; sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) - token = SXcmd_token(); token.key_base = "dry_run"; token.key_prefix = "--"; token.label = "Dry run"; token.help = "Do not submit the submission file, but just execute the command in order to create the submission file."; token.group = "advanced"; token.is_required = False; token.is_locked = False; token.is_reversed = False; token.filament_tab = ""; token.dependency_group = [['', '', '']]; token.default = False; token.restore = [[False], [False]]; token.type = "bool"; sxcmd.token_list.append(token); sxcmd.token_dict[token.key_base] = token - - sxcmd_list.append(sxcmd) - - sxcmd = SXcmd(); sxcmd.name = "transphire"; sxcmd.subname = ""; sxcmd.mode = ""; sxcmd.subset_config = ""; sxcmd.label = "TranSPHIRE GUI"; sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; sxcmd.mpi_support = False; sxcmd.mpi_add_flag = False; sxcmd.category = "sxc_utilities"; sxcmd.role = "sxr_util"; sxcmd.is_submittable = False + sxcmd = SXcmd(); + sxcmd.name = "sp_cter"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF Estimation"; + sxcmd.short_info = "Automated estimation of CTF parameters with error assessment, including Volta phase shift."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_image_path"; + token.key_prefix = ""; + token.label = "Input micrograph path pattern"; + token.help = "Specify input micrographs path pattern with a wild card (*) for any of Micrograph Modes. Images in bdb format cannot be used as input micrographs. In an advanced option, a particle stack file path can also be given using --stack_mode. However, Stack Mode is not supported by sp_gui. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The CTF parameters (partres file), rotationally averaged power spectra (rotinf), and micrograph thumbnails (thumb files) will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Micrograph selection file"; + token.help = "Specify path of a micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_one_ext"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrograph(s) or images in input particle stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "Cs"; + token.key_prefix = "--"; + token.label = "Microscope spherical aberration (Cs) [mm]"; + token.help = "The spherical aberration (Cs) of microscope used for imaging. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ac"; + token.key_prefix = "--"; + token.label = "Amplitude contrast [%]"; + token.help = "The amplitude contrast is in the range of 7% - 14%. The value depends on the thickness of the ice embedding the particles, among other factors. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "f_start"; + token.key_prefix = "--"; + token.label = "Lowest resolution [A]"; + token.help = "Lowest resolution used in the CTF estimation. Determined automatically if not given. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "f_stop"; + token.key_prefix = "--"; + token.label = "Highest resolution [A]"; + token.help = "Highest resolution used in the CTF estimation. Determined automatically if not given. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "wn"; + token.key_prefix = "--"; + token.label = "CTF window size [Pixels]"; + token.help = "The window size should be slightly larger than particle box size. This will be ignored in Stack Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "512"; + token.restore = [['512'], ['512']]; + token.type = "ctfwin"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "kboot"; + token.key_prefix = "--"; + token.label = "Number of CTF estimates per micrograph"; + token.help = "Used for error assessment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "16"; + token.restore = [['16'], ['16']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overlap_x"; + token.key_prefix = "--"; + token.label = "X overlap [%]"; + token.help = "Overlap between micrograph windows in the x direction. This will be ignored in Stack Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "50"; + token.restore = [['50'], ['50']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overlap_y"; + token.key_prefix = "--"; + token.label = "Y overlap [%]"; + token.help = "Overlap between micrograph windows in the y direction. This will be ignored in Stack Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "50"; + token.restore = [['50'], ['50']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_x"; + token.key_prefix = "--"; + token.label = "Edge x [pixels]"; + token.help = "Specifies micrograph exclusion margin in the x direction. This will be ignored in Stack Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_y"; + token.key_prefix = "--"; + token.label = "Edge y [pixels]"; + token.help = "Specifies micrograph exclusion margin in the y direction. This will be ignored in Stack Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of inputs"; + token.help = "Create a text file containing the list of inconsistent Micrograph ID entries (i.e. inconsist_mic_list_file.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "debug_mode"; + token.key_prefix = "--"; + token.label = "Enable debug mode"; + token.help = "Print out debug information. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "vpp"; + token.key_prefix = "--"; + token.label = "Volta Phase Plate Dataset"; + token.help = "UNDER DEVELOPMENT! Estimate phase shift. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "defocus_min"; + token.key_prefix = "--"; + token.label = "Minimum defocus search [um]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "0.3"; + token.restore = [['0.3'], ['0.3']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "defocus_max"; + token.key_prefix = "--"; + token.label = "Maximum defocus search [um]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "9.0"; + token.restore = [['9.0'], ['9.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "defocus_step"; + token.key_prefix = "--"; + token.label = "Defocus search step [um]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "phase_min"; + token.key_prefix = "--"; + token.label = "Minimum phase search [degrees]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "phase_max"; + token.key_prefix = "--"; + token.label = "Maximum phase search [degrees]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "175.0"; + token.restore = [['175.0'], ['175.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "phase_step"; + token.key_prefix = "--"; + token.label = "Phase search step [degrees]"; + token.help = "UNDER DEVELOPMENT! This is applicable only with --vpp option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['vpp', 'True', 'False']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('vpp', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "pap"; + token.key_prefix = "--"; + token.label = "Use PW spectrum"; + token.help = "UNDER DEVELOPMENT! Use power spectrum for CTF parameter search instead of amplitude. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_gui_cter"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF Assessment"; + sxcmd.short_info = "GUI tool to assess and sort micrographs according to their CTF parameters estimated by sp_cter."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "cter_ctf_file"; + token.key_prefix = ""; + token.label = "File containing CTF parameters"; + token.help = "This file is produced by sp_cter and normally called partres.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_cter_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ctffind"; + token.key_prefix = "--"; + token.label = "ctffind"; + token.help = "Use CTFFIND outputs (e.g., PWROT_DIR/*_avrot.txt, POWER2D_DIR/*.mrc). If using this option, you may need to specify the advanced parameters pwrot_dir and power2d_dir "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pwrot_dir"; + token.key_prefix = "--"; + token.label = "1D profile directory"; + token.help = "Directory for 1D profiles "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "pwrot"; + token.restore = [['pwrot'], ['pwrot']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "power2d_dir"; + token.key_prefix = "--"; + token.label = "2D power-spectrum directory"; + token.help = "Directory for 2D power spectra "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "power2d"; + token.restore = [['power2d'], ['power2d']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "micthumb_dir"; + token.key_prefix = "--"; + token.label = "2D power-spectrum directory"; + token.help = "Directory for 2D power spectra "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "micthumb"; + token.restore = [['micthumb'], ['micthumb']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "resample_micrographs"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Resample Micrographs"; + sxcmd.short_info = "Resample micrographs in input directory specified by input micrograph pattern with user-specified ratio. This operation changes the image dimensitions and the pixel size. Mainly, it is designed to reduce the demensions and pixel size of micrographs taken with the super resolution mode of the K2 direct electron detector."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input micrograph path pattern"; + token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. bdb files cannot be selected as input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resampling ratio"; + token.help = "Specify ratio between new and original pixel size. Use a value between 0.0 and 1.0 (exclusive both ends). "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Micrograph selecting list"; + token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be .txt. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of Micrograph ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info_TIMESTAMP.txt). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "organize_micrographs"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Organize Micrographs/Movies"; + sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "source_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Source micrograph/movies path pattern"; + token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Micrograph/Movie selection file"; + token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "select_mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "destination_directory"; + token.key_prefix = ""; + token.label = "Destination directory"; + token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reverse"; + token.key_prefix = "--"; + token.label = "Reverse operation"; + token.help = "Move back micrographs/movies from the destination directory to the source directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "meridien"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Meridien)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "refinement_dir"; + token.key_prefix = ""; + token.label = "Meridien directory"; + token.help = "Path to Meridien directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "manual"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Stack)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume_path"; + token.key_prefix = ""; + token.label = "Path to volume"; + token.help = "Path to volume. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Params file"; + token.help = "Path to params file "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk"; + token.key_prefix = "--"; + token.label = "Path to chunk file"; + token.help = "Path to chunk file "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume2"; + token.key_prefix = "--"; + token.label = "Path to second volume"; + token.help = "Path to second half volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "transphire"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "TranSPHIRE GUI"; + sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_cter"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_cryolo_predict"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "crYOLO - predict"; + sxcmd.short_info = "Prediction with crYOLO, a deep learning high accuracy particle picking procedure."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "cryolo_predict_path"; + token.key_prefix = "--"; + token.label = "crYOLO predict executable"; + token.help = "Path to the cryolo_predict.py in your crYOLO environment "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "config_path"; + token.key_prefix = ""; + token.label = "Config file"; + token.help = "Path of the crYOLO config file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_json"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_dir"; + token.key_prefix = ""; + token.label = "Image directory"; + token.help = "Folder which contain all images. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "model_path"; + token.key_prefix = ""; + token.label = "Model path"; + token.help = "Path to the trained model. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to write the box files. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "confidence_threshold"; + token.key_prefix = "--"; + token.label = "Confidence threshold [0-1]"; + token.help = "Confidence threshold for picking. Particles with a confidence threshold lower than this value will be discarded. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.3"; + token.restore = [['0.3'], ['0.3']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu"; + token.key_prefix = "--"; + token.label = "GPUs"; + token.help = "List of GPUs to use, separated by commas if more than one. If no GPU is present, be sure to supply the non-GPU executable. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu_fraction"; + token.key_prefix = "--"; + token.label = "GPU memory fraction"; + token.help = "Specify the fraction of memory per GPU used by crYOLO during prediction. Only values between 0.0 and 1.0 are allowed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "num_cpu"; + token.key_prefix = "--"; + token.label = "Number of CPUs"; + token.help = "Number of CPUs used during prediction. By default it will use half of the available CPUs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "otf"; + token.key_prefix = "--"; + token.label = "On the fly filtering"; + token.help = "If checked, the images are filtered on the fly and not saved to disk. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "min_distance"; + token.key_prefix = "--"; + token.label = "Minimum distance"; + token.help = "Particles with a distance less than this value (in pixel) will be removed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_mode"; + token.key_prefix = "--"; + token.label = "Filament mode [Yes/No]"; + token.help = "Check if you want to use the filament mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [Pixel]"; + token.help = "Width of your filament in pixel. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "min_box_per_filament"; + token.key_prefix = "--"; + token.label = "Minimum number of boxes per filament"; + token.help = "Specifies the minimum number of boxes per filament. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; + token.default = "6"; + token.restore = [['6'], ['6']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "box_distance"; + token.key_prefix = "--"; + token.label = "Box distance"; + token.help = "Distance between two filament boxes in pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nosplit"; + token.key_prefix = "--"; + token.label = "Don't split curved filaments"; + token.help = "If checked, the filament mode does not split curved filaments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nomerging"; + token.key_prefix = "--"; + token.label = "Don't merge filaments"; + token.help = "If checked, the filament mode does not merge filaments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['filament_mode', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_mode', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_window"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Particle Extraction"; + sxcmd.short_info = "Window particles from micrographs using the particle coordinates."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input micrograph path pattern"; + token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. bdb files cannot be selected as input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_coordinates_pattern"; + token.key_prefix = ""; + token.label = "Input coordinates path pattern"; + token.help = "Specify path pattern of input coordinates files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and coordinates file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_coords_any"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_ctf_params_source"; + token.key_prefix = ""; + token.label = "CTF parameters source"; + token.help = "Specify the file produced by sp_cter and normally called partres.txt for cryo data. For negative staining data, enter pixel size [A/Pixels]. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_cter_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Micrograph selection file"; + token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "coordinates_format"; + token.key_prefix = "--"; + token.label = "Coordinate file format"; + token.help = "Allowed values are 'sphire', 'eman1', 'eman2', 'cryolo,'cryolo_helical_segmented' or 'spider'. The sphire, eman2, and spider formats use the particle center as coordinates. The eman1 format uses the lower left corner of the box as coordinates. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cryolo"; + token.restore = [['cryolo', 'eman1', 'eman2', 'cryolo_helical_segmented'], + ['cryolo', 'eman1', 'eman2', 'cryolo_helical_segmented']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "The x and y dimensions of square area to be windowed. The box size after resampling is assumed when resample_ratio < 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_invert"; + token.key_prefix = "--"; + token.label = "Invert image contrast"; + token.help = "Indicate if image contrast should be inverted or not. Do not invert for negative staining data. By default, the image contrast will be inverted for cryo data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "limit_ctf"; + token.key_prefix = "--"; + token.label = "Use CTF limit filter"; + token.help = "Frequencies where CTF oscillations cannot be properly modeled with the resampled pixel size will be discarded in the images with the appropriate low-pass filter. This flag has no effect when the CTER CTF File is not specified by the CTF paramters source argument. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "astigmatism_error"; + token.key_prefix = "--"; + token.label = "Astigmatism error limit [Degrees]"; + token.help = "Set astigmatism to zero for all micrographs where the angular error computed by sp_cter is larger than the desired value. This parameter has no effect when the CTER CTF File is not specified by the CTF paramters source argument. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "360.0"; + token.restore = [['360.0'], ['360.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Image size reduction factor (<1)"; + token.help = "Use a value between 0.0 and 1.0 (excluding 0.0). The new pixel size will be automatically recalculated and stored in CTF paramers when resample_ratio < 1.0 is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of inputs"; + token.help = "Create a text file containing the list of inconsistent Micrograph ID entries (i.e. inconsist_mic_list_file.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [Pixels]"; + token.help = "Filament width for the creation of the rectangular mask. If -1 is selected, no mask will be applied. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2bdb"; + sxcmd.subname = ""; + sxcmd.mode = "makevstack"; + sxcmd.subset_config = "fullset"; + sxcmd.label = "Particle Stack BDB"; + sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "makevstack"; + token.key_prefix = "--"; + token.label = "Output virtual image stack"; + token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_bdb_stack_pattern"; + token.key_prefix = ""; + token.label = "Input BDB image stack pattern"; + token.help = "Specify file path pattern of stack subsets created in particle extraction using a wild card /'*/' (e.g. /'//sp_window_output_dir//*/'). The stack subsets are located in the sp_window output directory."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_star"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Particle Stack Star"; + sxcmd.short_info = "Star file handler for creating vstacks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "root_dir"; + token.key_prefix = ""; + token.label = "Input Directory"; + token.help = "The root directory where all the data is present. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "makevstack"; + token.key_prefix = "--"; + token.label = "Output Star file"; + token.help = "Creates a 'virtual' star stack with its own metadata but the data taken from the (filtered) list of stacks. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "List"; + token.help = "Specify the name of a file with a list of images to use in creation of virtual stacks. Please see source for details. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "exlist"; + token.key_prefix = "--"; + token.label = "Exlist"; + token.help = "Specify the name of a file with a list of images to not use in creation of virtual stacks. Please see source for details. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Step"; + token.help = "Specify <init>,<step>[,<max>]. Processes only a subset of the input data. For example, 0,2 would process only the even numbered particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_cryolo_train"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "crYOLO - training"; + sxcmd.short_info = "Training of crYOLO, a deep learning high accuracy particle picking procedure."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "cryolo_train_path"; + token.key_prefix = "--"; + token.label = "crYOLO train executeable"; + token.help = "Path to the cryolo_train.py in your crYOLO environment "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_diameter"; + token.key_prefix = ""; + token.label = "Particle diameter [Pixel]"; + token.help = "Particle diameter in pixels. This size will be used for as box size for picking. Should be as small as possible. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "training_dir"; + token.key_prefix = ""; + token.label = "Training image directory"; + token.help = "Folder which contains all images. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "annot_dir"; + token.key_prefix = ""; + token.label = "Annotation directory"; + token.help = "Box or star files used for training. Files should have the same name as the images, with the appropriate extension. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "architecture"; + token.key_prefix = "--"; + token.label = "Network architecture"; + token.help = "Type of network that is trained. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "PhosaurusNet"; + token.restore = [['PhosaurusNet'], ['PhosaurusNet']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_size"; + token.key_prefix = "--"; + token.label = "Input image dimension [Pixel]"; + token.help = "Dimension of the image used as input by the network. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1024"; + token.restore = [['1024'], ['1024']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "num_patches"; + token.key_prefix = "--"; + token.label = "Number of patches"; + token.help = "The number of patches (e.g 2x2) the image is divided into and classified separately. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overlap_patches"; + token.key_prefix = "--"; + token.label = "Patch overlap [Pixel]"; + token.help = "The amount of overlap the patches will overlap "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "train_times"; + token.key_prefix = "--"; + token.label = "Repeat images"; + token.help = "How often a images is augmented and repeated in one epoch. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10"; + token.restore = [['10'], ['10']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pretrained_weights_name"; + token.key_prefix = "--"; + token.label = "Pretrained weights name"; + token.help = "Name of the pretrained model "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cryolo_model.h5"; + token.restore = [['cryolo_model.h5'], ['cryolo_model.h5']]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "saved_weights_name"; + token.key_prefix = "--"; + token.label = "Saved weights name"; + token.help = "Name of the model to save "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cryolo_model.h5"; + token.restore = [['cryolo_model.h5'], ['cryolo_model.h5']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "batch_size"; + token.key_prefix = "--"; + token.label = "Batch size"; + token.help = "How many patches are processed in parallel. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fine_tune"; + token.key_prefix = "--"; + token.label = "Fine tune mode"; + token.help = "Set it to true if you only want to use the fine tune mode. Don't forget to choose an appropriate pretrained model (like the general model) that is refined. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "warmup"; + token.key_prefix = "--"; + token.label = "Warm up epochs"; + token.help = "Number of warmup epochs. If you fine tune a model, set it to zero. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "learning_rate"; + token.key_prefix = "--"; + token.label = "Learning rate"; + token.help = "Learning rate used during training. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0001"; + token.restore = [['0.0001'], ['0.0001']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "np_epoch"; + token.key_prefix = "--"; + token.label = "Number of epochs"; + token.help = "Maximum number of epochs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "object_scale"; + token.key_prefix = "--"; + token.label = "Object loss scale"; + token.help = "Loss scale for object. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_object_scale"; + token.key_prefix = "--"; + token.label = "Background loss scale"; + token.help = "Loss scale for background. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "coord_scale"; + token.key_prefix = "--"; + token.label = "Coordinates loss scale"; + token.help = "Loss scale for coordinates. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "valid_image_dir"; + token.key_prefix = "--"; + token.label = "Path to validation images"; + token.help = "Images used "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "valid_annot_dir"; + token.key_prefix = "--"; + token.label = "Path to validation annotations"; + token.help = "Path to the validation box files "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skiplowpass"; + token.key_prefix = "--"; + token.label = "Skip low pass filtering"; + token.help = "Set it to true if you want to skip the low pass filter "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cutoff"; + token.key_prefix = "--"; + token.label = "Low pass cutoff"; + token.help = "Cut off for low pass filter. Should be between 0 and 0.5. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skiplowpass', 'False', 'False']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "filtered_dir"; + token.key_prefix = "--"; + token.label = "Filtering directory"; + token.help = "Path to write filtered images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cryolo_filtered_micrographs"; + token.restore = [['cryolo_filtered_micrographs'], ['cryolo_filtered_micrographs']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "usejanni"; + token.key_prefix = "--"; + token.label = "Use JANNI for denoising"; + token.help = "Set it to true if you want to use JANNI for denoising. Low pass filtering has to be skipped. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "janni_model"; + token.key_prefix = "--"; + token.label = "JANNI model"; + token.help = "Path to JANNI model "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "janni_overlap"; + token.key_prefix = "--"; + token.label = "JANNI patch overlap"; + token.help = "Overlap of patches in pixel "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; + token.default = "24"; + token.restore = [['24'], ['24']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "janni_batches"; + token.key_prefix = "--"; + token.label = "JANNI number batches"; + token.help = "Number of batches when using JANNI "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skiplowpass', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skiplowpass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "gpu"; + token.key_prefix = "--"; + token.label = "GPUs"; + token.help = "List of GPUs to use, separated by commas. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu_fraction"; + token.key_prefix = "--"; + token.label = "GPU memory fraction"; + token.help = "Specify the fraction of memory per GPU used by crYOLO during training. Only values between 0.0 and 1.0 are allowed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "num_cpu"; + token.key_prefix = "--"; + token.label = "Number of CPUs"; + token.help = "Number of CPUs used during training. By default it will use half of the available CPUs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "restacking"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Restacking"; + sxcmd.short_info = "Generate all necessary information to restack the input stack (i.e., particle image ID list, CTF parameters list, projection parameters list) while applying micrograph selection list. Optionally, the command can directly output the virtual stack. In addition, this command can be used to generate all parameters files for reboxing (i.e. original/centered particle coordinates list files, CTF parameters list, original/centered projection parameters list as well as micrograph selection file). Optionally, user can provided a 3D shift to recenter the projection parameters and so the particle coordinates."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_bdb_stack_path"; + token.key_prefix = ""; + token.label = "Input bdb image stack"; + token.help = "Specify the input bdb image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Micrograph/Movie selection file"; + token.help = "Specify path to text file containing a list of selected micrograph/movie names or paths. The particles associated with the micrographs/movies in this list will be processed. The file extension must be .txt. The directory path of each entry will be ignored if there is any. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "save_vstack"; + token.key_prefix = "--"; + token.label = "Save virtual stack"; + token.help = "Use this option to save the virtual stack. By default, the virtual stack will not be generated. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sv_vstack_basename"; + token.key_prefix = "--"; + token.label = "Virtual stack basename"; + token.help = "Specify the basename of output virtual stack file. It cannot be empty string or only white spaces. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['save_vstack', 'True', 'False']]; + token.default = "vstack"; + token.restore = [['vstack'], ['vstack']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('save_vstack', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "reboxing"; + token.key_prefix = "--"; + token.label = "Generate reboxing information"; + token.help = "Prepare reboxing by extracting coordinates from the input stack headers, then center them according to projection parameters in the header and user-provided 3D shift. If the headers do not contain projection parameters, the program assumes the projection parameters are all zeros (null alignment). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rb_box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "For --reboxing option, specify the x and y dimensions of square area to be windowed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['reboxing', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('reboxing', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_rewindow"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Particle Reextraction"; + sxcmd.short_info = "Rewindow particles from micrographs using the information stored in rebox files."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input micrograph path pattern"; + token.help = "Specify path pattern of input micrographs with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and rebox file. bdb files cannot be selected as input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_rebox_pattern"; + token.key_prefix = ""; + token.label = "Input rebox path pattern"; + token.help = "Specify path pattern of input rebox files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated input micrograph. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_rebox_rbx"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Micrograph selection file"; + token.help = "Specify a name of micrograph selection list text file for Selected Micrographs Mode. The file extension must be '.txt'. Alternatively, the file name of a single micrograph can be specified for Single Micrograph Mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "The x and y dimensions of square area to be windowed. The box size after resampling is assumed when mic_resample_ratio < 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_invert"; + token.key_prefix = "--"; + token.label = "Invert image contrast"; + token.help = "Indicate if image contrast should be inverted or not. Do not invert for negative staining data. By default, the image contrast will be inverted for cryo data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mic_resample_ratio"; + token.key_prefix = "--"; + token.label = "Image size reduction factor (<1)"; + token.help = "Use a value between 0.0 and 1.0 (excluding 0.0). The new pixel size will be automatically recalculated and stored in CTF paramers when mic_resample_ratio < 1.0 is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "swap_ctf_params"; + token.key_prefix = "--"; + token.label = "Swap CTF parameters"; + token.help = "Swaps CTF parameters by setting the CTF parameters in the specified CTER partres file while ignoring the CTF parameters in the input rebox parameters file. Typically, specify the file produced by sp_cter and normally called partres.txt. Alternatively, enter pixel size [A/Pixels] to simulate ideal CTF. By default, the program uses the CTF parameters in the input rebox parameters file. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_cter_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of Micrograph ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info_TIMESTAMP.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2boxer_old"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Particle Coordinates"; + sxcmd.short_info = "Generate files containing particle coordinates for all input micrographs by picking particles manual and/or automatically."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_micrograph_list"; + token.key_prefix = ""; + token.label = "Input micrographs"; + token.help = "Wild cards (e.g. *) can be used to specify a list of micrographs. Not recommended if their number is very large. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_one_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "boxsize"; + token.key_prefix = "--"; + token.label = "Box size [Pixels]"; + token.help = "Box size for extraction of particle images. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert"; + token.key_prefix = "--"; + token.label = "Invert contrast"; + token.help = "Invert contrast of micrographs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Verbose level. Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2boxer"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Particle Coordinates (NEW)"; + sxcmd.short_info = "Generate files containing particle coordinates for all input micrographs by picking particles manual and/or automatically."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_micrograph_list"; + token.key_prefix = ""; + token.label = "Input micrograph list"; + token.help = "Wild cards (e.g. *) can be used to specify a list of micrographs. Not recommended if their number is very large. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_one_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Angstroms per pixel for all images. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "boxsize"; + token.key_prefix = "--"; + token.label = "Box size [Pixels]"; + token.help = "Box size in pixels. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ptclsize"; + token.key_prefix = "--"; + token.label = "Particle diameter [Pixels]"; + token.help = "Longest axis of particle in pixels (diameter, not radius). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert"; + token.key_prefix = "--"; + token.label = "Invert input contrast"; + token.help = "Preferably, particles should be bright on a dark background. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_ctf"; + token.key_prefix = "--"; + token.label = "Disable CTF estimation"; + token.help = "Disable CTF estimation. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gui"; + token.key_prefix = "--"; + token.label = "Interactive GUI mode"; + token.help = "Use interactive GUI mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "write_dbbox"; + token.key_prefix = "--"; + token.label = "Export EMAN1 box files"; + token.help = "Export EMAN1 box files (.box extension). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "unboxedonly"; + token.key_prefix = "--"; + token.label = "Include only unboxed micrographs"; + token.help = "Only include image files without existing box locations. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "write_ptcls"; + token.key_prefix = "--"; + token.label = "Save selected particle"; + token.help = "Extract selected particles from micrographs and write to disk. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allmicrographs"; + token.key_prefix = "--"; + token.label = "Include all micrographs in a directory"; + token.help = "Add all images from micrographs folder. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "suffix"; + token.key_prefix = "--"; + token.label = "Micrograph suffix"; + token.help = "Suffix of the micrographs used for particle picking (i.e. suffix=goodali will use micrographs end with _goodali.hdf). It is only useful when --allmicrographs option is True. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['allmicrographs', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('allmicrographs', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cs"; + token.key_prefix = "--"; + token.label = "Microscope spherical aberration (Cs) [mm]"; + token.help = "The spherical aberration (Cs) of microscope used for imaging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ac"; + token.key_prefix = "--"; + token.label = "Amplitude contrast [%]"; + token.help = "The typical amplitude contrast is in the range of 7% - 14%. The value mainly depends on the thickness of the ice embedding the particles. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "autopick"; + token.key_prefix = "--"; + token.label = "Perform automatic particle picking"; + token.help = "Provide mode and parameter string (eg - auto_local:threshold=5.5). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "threads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "Number of threads to run in parallel on a single computer. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "organize_micrographs"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Organize Micrographs/Movies"; + sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "source_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Source micrograph/movies path pattern"; + token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Micrograph/Movie selection file"; + token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "select_mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "destination_directory"; + token.key_prefix = ""; + token.label = "Destination directory"; + token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reverse"; + token.key_prefix = "--"; + token.label = "Reverse operation"; + token.help = "Move back micrographs/movies from the destination directory to the source directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_cryolo_boxmanager"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "crYOLO - boxmanager"; + sxcmd.short_info = "Displays boxfiles on images. Allows creation of new training data for crYOLO."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "cryolo_bm_path"; + token.key_prefix = "--"; + token.label = "crYOLO boxmanager executable"; + token.help = "Path to crYOLO boxmanager executable "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_dir"; + token.key_prefix = "--"; + token.label = "Input image directory"; + token.help = "Path to input images "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_dir"; + token.key_prefix = "--"; + token.label = "Annotation directory"; + token.help = "Path to annotation data like .box or .star files "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_window"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_isac2"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "ISAC2 - 2D Clustering"; + sxcmd.short_info = "Iterative Stable Alignment and Clustering (ISAC) of a 2D image stack."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack_file"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Images must to be square (nx=ny). The stack can be either in .bdb or in .hdf format. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "General ISAC output directory to store all results. If the directory already exists ISAC will only run in continuation mode (see advanced parameter restart). "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Radius of the particle in pixels. ISAC cannot offer a default here since the value will depend on the particle im question. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp"; + token.key_prefix = "--"; + token.label = "Images per class"; + token.help = "Ideally the number of images per class. In practice this value determines the number of classes K = N / img_per_grp, where N is the total number of images in the input stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "200"; + token.restore = [['200'], ['200']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "CTF"; + token.key_prefix = "--"; + token.label = "CTF phase flipping"; + token.help = "Use for cryo datasets. If set to True the data will be phase-flipped using CTF information included in the image headers. Cannot be used together with the VPP option. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['VPP', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('VPP', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "VPP"; + token.key_prefix = "--"; + token.label = "Phase Plate data"; + token.help = "Use this option if the dataset is taken with a phase plate. Cannot be used together with the CTF option. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['CTF', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('CTF', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Translation search range [Pixels]"; + token.help = "The translational search range. Change with care; higher values will incur significantly higher processing costs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "thld_err"; + token.key_prefix = "--"; + token.label = "Pixel error threshold [Pixels]"; + token.help = "Used as a threshold value when checking cluster stability. The pixel error is defined as the root mean square of distances between corresponding pixels from set of found transformations and their average transformation; it depends linearly on square of radius (parameter ou). units - pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.7"; + token.restore = [['0.7'], ['0.7']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_radius"; + token.key_prefix = "--"; + token.label = "Target particle radius [Pixels]"; + token.help = "Particle radius used by ISAC2 to process the data. All particle images will be re-scaled to match their particle radius with this radius. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_nx"; + token.key_prefix = "--"; + token.label = "Target particle image size [Pixels]"; + token.help = "Image size used by ISAC2 to process the data. particle images will first be resized according to target particle radius (see above) and then cropped or padded to achieve the target image size. When xr > 0, the final image size for ISAC2 processing is target_nx + xr - 1 "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "76"; + token.restore = [['76'], ['76']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ir"; + token.key_prefix = "--"; + token.label = "Inner ring [Pixels]"; + token.help = "Radius of the inner-most ring when resampling images to polar coordinates. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rs"; + token.key_prefix = "--"; + token.label = "Ring step [Pixels]"; + token.help = "Radius step size when resampling images to polar coordinates. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step [Pixels]"; + token.help = "Translational search step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit"; + token.key_prefix = "--"; + token.label = "Reference-free alignment iterations"; + token.help = "The number of iterations for reference-free alignments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "30"; + token.restore = [['30'], ['30']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center_method"; + token.key_prefix = "--"; + token.label = "Centering method"; + token.help = "Method to center global 2D average during the initial prealignment of the data (0: no centering; -1: average shift method; please see function center_2D in sp_utilities.py for methods 1-7). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dst"; + token.key_prefix = "--"; + token.label = "Discrete angle used for within-group alignment"; + token.help = "Discrete angle used for within-group alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "90.0"; + token.restore = [['90.0'], ['90.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FL"; + token.key_prefix = "--"; + token.label = "Lowest filter frequency [1/Pixel]"; + token.help = "Lowest frequency used for the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.2"; + token.restore = [['0.2'], ['0.2']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FH"; + token.key_prefix = "--"; + token.label = "Highest filter frequency [1/Pixel]"; + token.help = "Highest frequency used for the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.45"; + token.restore = [['0.45'], ['0.45']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FF"; + token.key_prefix = "--"; + token.label = "Tangent filter fall-off"; + token.help = "The fall-off of the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.2"; + token.restore = [['0.2'], ['0.2']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "init_iter"; + token.key_prefix = "--"; + token.label = "Maximum generations"; + token.help = "Maximum number of generation iterations performed for a given subset. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "7"; + token.restore = [['7'], ['7']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "iter_reali"; + token.key_prefix = "--"; + token.label = "SAC stability check interval"; + token.help = "Defines every how many iterations the SAC stability checking is performed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stab_ali"; + token.key_prefix = "--"; + token.label = "Number of alignments for stability check"; + token.help = "The number of alignment runs when checking stability. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "minimum_grp_size"; + token.key_prefix = "--"; + token.label = "Minimum size of reproducible classes"; + token.help = "Minimum size of reproducible classes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "60"; + token.restore = [['60'], ['60']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rand_seed"; + token.key_prefix = "--"; + token.label = "Seed"; + token.help = "Random seed set before calculations. Useful for testing purposes. By default, ISAC2 sets a random seed number. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_prealignment"; + token.key_prefix = "--"; + token.label = "Do pre-alignment"; + token.help = "Indicate if pre-alignment should be used or not. Do not use pre-alignment if images are already centered. The 2dalignment directory will still be generated but the parameters will be zero. By default, do pre-alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "restart"; + token.key_prefix = "--"; + token.label = "Restart run"; + token.help = "0: Restart ISAC2 after the last completed main iteration (i.e. the directory must contain finished file); k: Restart ISAC2 after k-th main iteration, it has to be completed (i.e. the directory must contain finished file), and higer iterations will be removed; Default: Do not restart. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_ordering"; + token.key_prefix = "--"; + token.label = "Skip ordered class averages"; + token.help = "Skip the creation of the ordered class averages. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [Pixels]"; + token.help = "When this is set to a non-default value, ISAC assumes helical data, in which case particle images will be subjected to rectangular masking of the given this value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_mask_ignore"; + token.key_prefix = "--"; + token.label = "Ignore filament masking (filament use only)"; + token.help = "ONLY RELEVANT IF parameter filament_width is set to a non-default value. When processing helical particle images rectangular masking is used (A) to normalize and (B) to mask the actual particle images. The latter can be disabled by setting this flag to True. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_isac2_gpu"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "GPU ISAC - 2D Clustering"; + sxcmd.short_info = "Iterative Stable Alignment and Clustering (ISAC) of a 2D image stack, using the GPU."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack_file"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Images must to be square (nx=ny). The stack can be either in .bdb or in .hdf format. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "General ISAC output directory to store all results. If the directory already exists ISAC will only run in continuation mode (see advanced parameter restart). "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Radius of the particle in pixels. ISAC cannot offer a default here since the value will depend on the particle im question. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp"; + token.key_prefix = "--"; + token.label = "Images per class"; + token.help = "also defines number of classes K=(total number of images)/img_per_grp. If not specified, the value will be set to yield 200 classes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "CTF"; + token.key_prefix = "--"; + token.label = "CTF phase flipping"; + token.help = "Use for cryo datasets. If set to True the data will be phase-flipped using CTF information included in the image headers. Cannot be used together with the VPP option. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['VPP', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('VPP', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "VPP"; + token.key_prefix = "--"; + token.label = "Phase Plate data"; + token.help = "Use this option if the dataset is taken with a phase plate. Cannot be used together with the CTF option. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['CTF', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('CTF', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "gpu_devices"; + token.key_prefix = "--"; + token.label = "GPU devices"; + token.help = "Specify the GPUs to be used (e.g. --gpu_devices=0, or --gpu_devices=0,1 for one or two GPUs, respectively). Using nvidia-smi in the terminal will print out what GPUs are available. For a more detailed printout you can also use --gpu_info here in ISAC. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu_memory_use"; + token.key_prefix = "--"; + token.label = "GPU memory use"; + token.help = "Specify how much memory on the chosen GPUs ISAC is allowed to use. A value of 0.9 results in using 90% of the available memory (this is the default; higher percentages should be used with caution). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.9"; + token.restore = [['0.9'], ['0.9']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Translation search range [Pixels]"; + token.help = "The translational search range. Change with care; higher values will incur significantly higher processing costs. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "thld_err"; + token.key_prefix = "--"; + token.label = "Pixel error threshold [Pixels]"; + token.help = "Used as a threshold value when checking cluster stability. The pixel error is defined as the root mean square of distances between corresponding pixels from set of found transformations and their average transformation; it depends linearly on square of radius (parameter ou). units - pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.7"; + token.restore = [['0.7'], ['0.7']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_radius"; + token.key_prefix = "--"; + token.label = "Target particle radius [Pixels]"; + token.help = "Particle radius used by ISAC2 to process the data. All particle images will be re-scaled to match their particle radius with this radius. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_nx"; + token.key_prefix = "--"; + token.label = "Target particle image size [Pixels]"; + token.help = "Image size used by ISAC2 to process the data. particle images will first be resized according to target particle radius (see above) and then cropped or padded to achieve the target image size. When xr > 0, the final image size for ISAC2 processing is target_nx + xr - 1 "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "76"; + token.restore = [['76'], ['76']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ir"; + token.key_prefix = "--"; + token.label = "Inner ring [Pixels]"; + token.help = "Radius of the inner-most ring when resampling images to polar coordinates. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rs"; + token.key_prefix = "--"; + token.label = "Ring step [Pixels]"; + token.help = "Radius step size when resampling images to polar coordinates. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step [Pixels]"; + token.help = "Translational search step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit"; + token.key_prefix = "--"; + token.label = "Reference-free alignment iterations"; + token.help = "The number of iterations for reference-free alignments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "30"; + token.restore = [['30'], ['30']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center_method"; + token.key_prefix = "--"; + token.label = "Centering method"; + token.help = "Method for centering of global 2D averages during the initial prealignment of the data (0 : average centering; -1 : average shift method; please see center_2D in sp_utilities.py for methods 1-7). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dst"; + token.key_prefix = "--"; + token.label = "Discrete angle used for within-group alignment"; + token.help = "Discrete angle used for within-group alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "90.0"; + token.restore = [['90.0'], ['90.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FL"; + token.key_prefix = "--"; + token.label = "Lowest filter frequency [1/Pixel]"; + token.help = "Lowest frequency used for the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.2"; + token.restore = [['0.2'], ['0.2']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FH"; + token.key_prefix = "--"; + token.label = "Highest filter frequency [1/Pixel]"; + token.help = "Highest frequency used for the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.45"; + token.restore = [['0.45'], ['0.45']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "FF"; + token.key_prefix = "--"; + token.label = "Tangent filter fall-off"; + token.help = "The fall-off of the tangent filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.2"; + token.restore = [['0.2'], ['0.2']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "init_iter"; + token.key_prefix = "--"; + token.label = "Maximum generations"; + token.help = "Maximum number of generation iterations performed for a given subset. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "7"; + token.restore = [['7'], ['7']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "main_iter_limit"; + token.key_prefix = "--"; + token.label = "Main iteration limit"; + token.help = "If set to a positive value N, ISAC execution is halted after N main iterations. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "iter_reali"; + token.key_prefix = "--"; + token.label = "SAC stability check interval"; + token.help = "Defines every how many iterations the SAC stability checking is performed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stab_ali"; + token.key_prefix = "--"; + token.label = "Number of alignments for stability check"; + token.help = "The number of alignment runs when checking stability. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "minimum_grp_size"; + token.key_prefix = "--"; + token.label = "Minimum group size"; + token.help = "Minimum size of reproducible classes. If not specified, this value will be set to 60% of the 'img_per_group' value (see above). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rand_seed"; + token.key_prefix = "--"; + token.label = "Seed"; + token.help = "Random seed set before calculations. Useful for testing purposes. By default, ISAC2 sets a random seed number. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_prealignment"; + token.key_prefix = "--"; + token.label = "Do pre-alignment"; + token.help = "Indicate if pre-alignment should be used or not. Do not use pre-alignment if images are already centered. The 2dalignment directory will still be generated but the parameters will be zero. By default, do pre-alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "restart"; + token.key_prefix = "--"; + token.label = "Restart run"; + token.help = "0: Restart ISAC2 after the last completed main iteration (i.e. the directory must contain finished file); k: Restart ISAC2 after k-th main iteration, it has to be completed (i.e. the directory must contain finished file), and higer iterations will be removed; Default: Do not restart. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_ordering"; + token.key_prefix = "--"; + token.label = "Skip ordered class averages"; + token.help = "Skip the creation of the ordered class averages. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [Pixels]"; + token.help = "When this is set to a non-default value, ISAC assumes helical data, in which case particle images will be subjected to rectangular masking of the given this value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_mask_ignore"; + token.key_prefix = "--"; + token.label = "Ignore filament masking (filament use only)"; + token.help = "ONLY RELEVANT IF parameter filament_width is set to a non-default value. When processing helical particle images rectangular masking is used (A) to normalize and (B) to mask the actual particle images. The latter can be disabled by setting this flag to True. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu_info"; + token.key_prefix = "--"; + token.label = "GPU info"; + token.help = "Print detailed information about the selected GPUs, including the class limit which is relevant when using the --gpu_class_limit parameter. Use --gpu_devices to specify what GPUs you want to know about. NOTE: ISAC will stop after printing this information, so don't use this parameter if you intend to actually process any data. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_compute_isac_avg"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Beautifier"; + sxcmd.short_info = "Perform local 2D alignment of ISAC2 2D clustering results using the original pixel size and full CTF correction."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = "--"; + token.label = "Original image stack"; + token.help = "Data stack that used for the associated ISAC2 run. The particle images in this stack are used to create the full-sized class averages. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "isac_dir"; + token.key_prefix = "--"; + token.label = "ISAC2 run directory"; + token.help = "Path to the output directory of the associated ISAC2 run. This is the input directory for this command. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "This automatically-created output directory will contain results. By default, the program uses sharpen_DATA_AND_TIME for the name. If this is the same as ISAC2 run directory, the program automatically creates sharpen subdirectory under the ISAC2 run directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of particle images in input particle stack for the associated ISAC2 run. Use 1.0 in case of negative stain data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "There is no default radius. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "noctf"; + token.key_prefix = "--"; + token.label = "CTF correction"; + token.help = "Indicate if full CTF correction should be applied or not. Always use the CTF correction for cryo data, but not for negative stained data. By default, do full CTF correction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "local_alignment"; + token.key_prefix = "--"; + token.label = "Local alignment"; + token.help = "Indicate if local alignment should be applied or not. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = True; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [1/Pixel]"; + token.help = "Cutoff frequency of low-pass filter. =-1.0, do not apply the low-pass filter; =0.0, apply low pass filter to initial ISAC2 resolution; =1.0, to resolution after local alignment; else use user-provided cutoff in absolute frequency (>0.0 and <=0.45). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "abs_freq"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pw_adjustment"; + token.key_prefix = "--"; + token.label = "Power spectrum adjustment method"; + token.help = "Specify the method for the power spectrum (PWS) adjustment of 2-D averages to enhance averages. ='analytical_model' adjusts PWS to an analytic model; ='bfactor' adjusts PWS using B-factor; ='FILE_PATH' adjusts PWS to rotationally averaged 1D power spectrum stored in the text file; ='no_adjustment' skips adjustment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "analytical_model"; + token.restore = [['analytical_model'], ['analytical_model']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_start"; + token.key_prefix = "--"; + token.label = "Lower bound for B-factor estimation [A]"; + token.help = "Lower resolution bound of power spectrum for B-factor estimation. Specific to adjust to B-factor method. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "45.0"; + token.restore = [['45.0'], ['45.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "Bfactor"; + token.key_prefix = "--"; + token.label = "Use ad-hoc B-factor [A^2]"; + token.help = "Skip the automatic estimation and use user-provided ad-hoc B-factor (e.g. 25.0[A^2]) for the enhancement. By default, the program automatically estimates B-factor. Specific to adjust to B-factor method. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Local search range [Pixels]"; + token.help = "Translational search range for local alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Local search step [Pixels]"; + token.help = "Translational search step for local alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fh"; + token.key_prefix = "--"; + token.label = "High frequency search limit [1/Pixel]"; + token.help = "High frequency search limit in absolute frequency for local alignment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "abs_freq"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "maxit"; + token.key_prefix = "--"; + token.label = "Local alignment iterations"; + token.help = "The number of iterations for local aligment. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['local_alignment', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('local_alignment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "navg"; + token.key_prefix = "--"; + token.label = "Number of averages"; + token.help = "The number of averages to be process, starting from the first image. By default, uses all ISAC2 average images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1000000"; + token.restore = [['1000000'], ['1000000']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "isac_substack"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "ISAC2 Stack Subset"; + sxcmd.short_info = "Create a virtual subset stack consisting of particles acounted for by ISAC2 by retrieving particle numbers associated with the ISAC2 or Beautifier class averages. The command also saves a selection file containing the retrieved original image numbers and 2D alignment parameters. In addition, it stores the 2D alignment parameters to the stack header."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_star_stack_path"; + token.key_prefix = ""; + token.label = "Input Star image stack"; + token.help = "Specify the same Star image stack used for the associated ISAC2 run. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "ISAC2 or Beautifier run output directory"; + token.help = "Specify output directory of an ISAC2 or Beautifier run as an input to this command. From this directory, the program extracts the shrink ratio and 2D alignment parameters of the ISAC2 run or local 2D alignment parameters of the Beautifier run. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "isac_class_avgs_path"; + token.key_prefix = "--"; + token.label = "ISAC2 or Beautifier class averages path"; + token.help = "Specify path to a file containg ISAC2 or Beautifier class averages. The class averages can be fullset or selected subset, as long as they are associated with the input bdb image stack and contain class member information stored in the headers. By default, the program uses the same default name of ordered class averages in ISAC2 or Beautifier (i.e. ordered_class_averages.hdf). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "substack_basename"; + token.key_prefix = "--"; + token.label = "Stack subset basename"; + token.help = "Specify the basename of ISAC2 stack subset file. It cannot be empty string or only white spaces. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "isac_substack"; + token.restore = [['isac_substack'], ['isac_substack']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2bdb"; + sxcmd.subname = ""; + sxcmd.mode = "makevstack"; + sxcmd.subset_config = ""; + sxcmd.label = "Create Virtual Stack"; + sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "makevstack"; + token.key_prefix = "--"; + token.label = "Output virtual image stack"; + token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_bdb_stack_file"; + token.key_prefix = ""; + token.label = "Input BDB image stack"; + token.help = "Specify path to input BDB stack file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Image selection file"; + token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual bdb image stack from an existed stack or virtual stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) + token = SXcmd_token(); + token.key_base = "exlist"; + token.key_prefix = "--"; + token.label = "Image exclusion file"; + token.help = "Input exclusion text file containing a list of excluded image IDs (or indexes of the data subset) to create a new virtual bdb image stacks from an existed stack or virtual stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['step', '0,1', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Processes only subset"; + token.help = "Specify <init>,<step>[,<max>]. Process only a subset of the input data. For example, 0,2 would process only the even numbered particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['exlist', 'none', 'False']]; + token.default = "0,1"; + token.restore = [['0,1'], ['0,1']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_eval_isac"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Evaluate ISAC classes"; + sxcmd.short_info = "Separates stacks of particle images into stacks for each class."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_class_avgs"; + token.key_prefix = ""; + token.label = "Input class averages"; + token.help = "Set of 2D class averages, with particle-membership information in header. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particles"; + token.key_prefix = "--"; + token.label = "Input particle stack"; + token.help = "Required if particles will be processed (i.e., everything except simple class seperation or bandpass filtration). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "align_isac_dir"; + token.key_prefix = "--"; + token.label = "ISAC/Beautifier direrctory"; + token.help = "ISAC or beautifier directory, from which alignment parameters will be applied. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filtrad"; + token.key_prefix = "--"; + token.label = "Low-pass filter radius"; + token.help = "Low-pass filter radius. If pixel size is provided, then units will be Angstroms. If pixel size is not is not specified, program will assume units of absolute frequency (0..0.5). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size"; + token.help = "Pixel size, in Angstroms. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shrink"; + token.key_prefix = "--"; + token.label = "Downsampling factor"; + token.help = "Factor by which images will be downsampled. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "ctf"; + token.key_prefix = "--"; + token.label = "CTF-correction mode"; + token.help = "Allowed options are 'flip' (phase-flipping) and 'wiener' (phase and amplitude, like with beautifier). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = "None"; + token.restore = [['None', 'flip', 'wiener'], ['None', 'flip', 'wiener']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "chains_radius"; + token.key_prefix = "--"; + token.label = "Chains radius"; + token.help = "Alignment radius for generating ordered class averages internally. Units are pixels, on the scale of the input class averages. In other words, for ISAC averages, this value will typically be 29. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "nvec"; + token.key_prefix = "--"; + token.label = "Number of eigenimages"; + token.help = "Number of eigenimages to compute using principal component analysis. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "pca_radius"; + token.key_prefix = "--"; + token.label = "PCA radius"; + token.help = "Radius for principal component analysis (PCA). Only pixels within this radius will be examined using PCA. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "mask_binary"; + token.key_prefix = "--"; + token.label = "Binary mask file"; + token.help = "A binary mask file to use for principal component analysis. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "mask_drawn"; + token.key_prefix = "--"; + token.label = "Drawn mask file"; + token.help = "A drawn mask means that, using e2display.py or a similar program, a mask was drawn on top of a class average. The mask will be binarized according to the maximum of the class average, and that binary mask will be used for PCA. When running sp_eval_isac.py, the screen output will report the maximum pixel value among the class averages. Use a value exceeding that value for the pen intensity when drawing the mask using e2display.py. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nvec', '0', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nvec', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "bandpass_radius"; + token.key_prefix = "--"; + token.label = "Bandpass radius"; + token.help = "Applies a bandpass filter to class averages. Bandpass radius assumed to be in units of Angstroms if pixel size is provided. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'False']) + token = SXcmd_token(); + token.key_base = "write_centered"; + token.key_prefix = "--"; + token.label = "Apply centering"; + token.help = "Applies centering parameters from sp_center_2d3d.py. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particles', 'None', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particles', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "applyparams"; + token.key_prefix = "--"; + token.label = "Centering options"; + token.help = "Allowed centering options are 'combined' (shifts and rotation, both floating point) and 'intshifts' (integer shifts only, to avoid interpolation). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['write_centered', 'True', 'False']]; + token.default = "combined"; + token.restore = [['combined', 'intshifts'], ['combined', 'intshifts']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('write_centered', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Debug centering"; + token.help = "For use with centering option 'intshifts', to make sure that correct shifts are applied, rotation is applied, and averages are computed. If this flag is not activated, no averages will be generated. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['applyparams', 'intshifts', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('applyparams', []).append([token.key_base, 'intshifts', 'False']) + token = SXcmd_token(); + token.key_base = "bandpass_width"; + token.key_prefix = "--"; + token.label = "Bandpass width"; + token.help = "Width of bandpass filter, in units of absolute frequency (i.e., 0..0.5). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['bandpass_radius', 'None', 'True']]; + token.default = "0.03"; + token.restore = [['0.03'], ['0.03']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('bandpass_radius', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity"; + token.help = "Controls the amount of information written to the screen, ranging from 0..6. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_compare2d"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compare 2D images"; + sxcmd.short_info = "Find best match between two sets of 2D images."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "image_stack_1"; + token.key_prefix = ""; + token.label = "Input stack #1"; + token.help = "To each imagine in this stack, all of the images in the second input stack will be compared. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "image_stack_2"; + token.key_prefix = ""; + token.label = "Input stack #2"; + token.help = "Each image from this stack will be aligned to each image from the first input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where output files will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outterradius"; + token.key_prefix = "--"; + token.label = "Outer radius"; + token.help = "Outer radius in pixels. If not specified, the maximum allowed from the image dimension and maximum shift will be used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "normalize"; + token.key_prefix = "--"; + token.label = "Normalization mode"; + token.help = "Methods for displaying the images from the two inputs stacks. If both comes from the same source, uses 'None'. Other options: 'minmax' (sets the minimum and maximum for each image to constants), 'rops' (sets 1D rotational power spectra equal to each other), and 'sigmaone' (sets the average to 0 and sigma to 1). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None', 'minmax', 'rops', 'sigmaone'], ['None', 'minmax', 'rops', 'sigmaone']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxshift"; + token.key_prefix = "--"; + token.label = "Maximum shift"; + token.help = "Maximum shift allowed during alignment. Alignment will be slowed significantly as the maximum shift increases. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ringstep"; + token.key_prefix = "--"; + token.label = "Ring step"; + token.help = "Alignments will be computed at this radial increment, in pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen, from 0..2. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_cinderella_pred"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Automatic 2D class selection"; + sxcmd.short_info = "Classify classes into good and bad."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_isac"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "cinderella_path"; + token.key_prefix = ""; + token.label = "Cinderella predict executeable"; + token.help = "Path to the sp_cinderella_predict.py in your Cinderella environment "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_stack_cinderella"; + token.key_prefix = ""; + token.label = "Input stack"; + token.help = "Path to your class stack (.mrcs/.hdf). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to write results. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "model_path"; + token.key_prefix = ""; + token.label = "Model path"; + token.help = "Specifiy the path to your model file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "confidence_threshold"; + token.key_prefix = "--"; + token.label = "Confidence threshold"; + token.help = "Classes with a confidence higher as that threshold are classified as good. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "gpu"; + token.key_prefix = "--"; + token.label = "GPU ID"; + token.help = "ID of the GPU that should be used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "batch_size"; + token.key_prefix = "--"; + token.label = "Number of batches"; + token.help = "Number of mini-batches during prediction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "32"; + token.restore = [['32'], ['32']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_rviper"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Initial 3D Model - RVIPER"; + sxcmd.short_info = "Reproducible ab initio 3D structure determination. The program determines a validated initial intermediate resolution structure using a subset of class averages produced by ISAC2."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input images stack"; + token.help = "Subset of class averages, e.g., produced by ISAC2. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The automatically-created output directory will contain results. If the directory already exists, results will be written there, possibly overwriting previous runs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Use the same value as in ISAC2. It has to be less than half the box size. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the particle. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "moon_elimination"; + token.key_prefix = "--"; + token.label = "Eliminate disconnected regions"; + token.help = "Used to removed disconnected pieces from the model. As an argument it requires a comma-separated string with the mass in KDa and the pixel size in [A]. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "iteration_start"; + token.key_prefix = "--"; + token.label = "Restarting iteration"; + token.help = "Iteration from which to restart the program. 0 means go to the most recent one. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "n_rv_runs"; + token.key_prefix = "--"; + token.label = "RVIPER iterations"; + token.help = "Corresponds to main### output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "10"; + token.restore = [['10'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "n_v_runs"; + token.key_prefix = "--"; + token.label = "Minimum number of VIPER runs per RVIPER iterations"; + token.help = "Corresponds to run### output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "criterion_name"; + token.key_prefix = "--"; + token.label = "Stable projection criterion"; + token.help = "Used to decide if the solution is stable, i.e., whether projection images adopt similar orientations in independent runs of the program. Valid options are: '80th percentile', or 'fastest increase in the last quartile'. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "80th percentile"; + token.restore = [['80th percentile'], ['80th percentile']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_index_threshold_method"; + token.key_prefix = "--"; + token.label = "Outlier selection method"; + token.help = "Used to decide which images to keep. Valid options are: 'discontinuity_in_derivative', 'percentile', or 'angle_measure'. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "discontinuity_in_derivative"; + token.restore = [['discontinuity_in_derivative'], ['discontinuity_in_derivative']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "angle_threshold"; + token.key_prefix = "--"; + token.label = "Angle threshold"; + token.help = "Threshold used to remove projections if 'angle_measure' is used to decide the outliers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "30"; + token.restore = [['30'], ['30']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_percentile"; + token.key_prefix = "--"; + token.label = "Percentile for outlier"; + token.help = "Threshold above which images are considered outliers and removed if 'percentile' is used as outlier selection method. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "95.0"; + token.restore = [['95.0'], ['95.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ir"; + token.key_prefix = "--"; + token.label = "Inner rotational search radius [Pixels]"; + token.help = "Inner rotational search radius [Pixels]. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rs"; + token.key_prefix = "--"; + token.label = "Ring step size [Pixels]"; + token.help = "Step between rings used for the rotational search. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "X search range [Pixels]"; + token.help = "The translational search range in the x direction. Search will +/-xr range in steps of ts. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "yr"; + token.key_prefix = "--"; + token.label = "Y search range [Pixels]"; + token.help = "The translational search range in the y direction. If omitted it will be equal to the x search range. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Translational search step [Pixels]"; + token.help = "The search will be performed in -xr, -xr+ts, 0, xr-ts, xr, can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Projection angular step [Degrees]"; + token.help = "Projection angular step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center"; + token.key_prefix = "--"; + token.label = "Center 3D template"; + token.help = "-1: center of coordinates, 0: no centering; 1: center of gravity "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit1"; + token.key_prefix = "--"; + token.label = "Maximum iterations - GA step"; + token.help = "Maximum number of iterations for GA step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "400"; + token.restore = [['400'], ['400']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit2"; + token.key_prefix = "--"; + token.label = "Maximum iterations - Finish step"; + token.help = "Maximum iterations number of for Finish step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "50"; + token.restore = [['50'], ['50']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask"; + token.help = "Path to 3D mask file. By default, a spherical mask will be used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['filament_width', '-1', 'False']]; + token.default = "sphere"; + token.restore = [['sphere'], ['sphere']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_width', []).append([token.key_base, '-1', 'False']) + token = SXcmd_token(); + token.key_base = "L2threshold"; + token.key_prefix = "--"; + token.label = "GA stop threshold"; + token.help = "Defines the maximum relative dispersion of structures' L2 norms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.03"; + token.restore = [['0.03'], ['0.03']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ref_a"; + token.key_prefix = "--"; + token.label = "Projection generation method"; + token.help = "Method for generating the quasi-uniformly distributed projection directions. S - Saff algorithm, M - Markus 2019 algorithm or P - Penczek 1994 algorithm. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'P', 'M'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "n_shc_runs"; + token.key_prefix = "--"; + token.label = "GA population size"; + token.help = "This defines the number of quasi-independent structures generated. (same as --nruns parameter from sp_viper). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "doga"; + token.key_prefix = "--"; + token.label = "Threshold to start GA"; + token.help = "Do GA when the fraction of orientation that changes less than 1.0 degrees is at least this fraction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [1/Pixels]"; + token.help = "Using a hyperbolic tangent low-pass filter. Specify with absolute frequency. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.25"; + token.restore = [['0.25'], ['0.25']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Fall-off of for the hyperbolic tangent low-pass filter. Specify with absolute frequency. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pwreference"; + token.key_prefix = "--"; + token.label = "Power spectrum reference"; + token.help = "Text file containing a 1D reference power spectrum. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "spectrum1d"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "npad"; + token.key_prefix = "--"; + token.label = "Image padding factor"; + token.help = "Used by 3D reconstruction algorithm in the program. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta1"; + token.key_prefix = "--"; + token.label = "Minimum theta"; + token.help = "Lower bound for out-of-plane tilt angle. No tilt corresponds to 90 degrees. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta2"; + token.key_prefix = "--"; + token.label = "Maximum theta"; + token.help = "Upper bound for out-of-plane tilt angle. No tilt corresponds to 90 degrees. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "BILD resolution"; + token.help = "Resolution in dpi for angular distribution plot. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "72"; + token.restore = [['72'], ['72']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [Pixels]"; + token.help = "When this is set to a non-default value helical data is assumed in which case the input images will be aligned to a mask with this width. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['mask3D', 'sphere', 'False']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mask3D', []).append([token.key_base, 'sphere', 'False']) + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['filament_width', '-1', 'True'], ['mask3D', 'sphere', 'False']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('filament_width', []).append([token.key_base, '-1', 'True']); + sxcmd.dependency_dict.setdefault('mask3D', []).append([token.key_base, 'sphere', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_proj_compare"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compare Re-projections"; + sxcmd.short_info = "Compare re-projections to class averages."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Set of 2D images to be compared, i.e., class averages. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input volume"; + token.help = "Reconstruction for which re-projections will be computed. In RVIPER, this file is of the form main003/run002/rotated_volume.hdf. This volume must have the same dimensions as the input images. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mode"; + token.key_prefix = "--"; + token.label = "Comparison method"; + token.help = "Choices are: viper, projmatch, and meridien. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "projmatch"; + token.restore = [['projmatch', 'viper', 'meridien'], ['projmatch', 'viper', 'meridien']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "classangles"; + token.key_prefix = "--"; + token.label = "VIPER - Projection parameter file"; + token.help = "Parameter file containing projection angles. Not required if the projection parameters are stored in the header of the input images, which for ISAC2 is generally not the case. In RVIPER, this file is of the form main003/run002/rotated_reduced_params.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) + token = SXcmd_token(); + token.key_base = "classselect"; + token.key_prefix = "--"; + token.label = "VIPER - Image selection file"; + token.help = "Input selection containing list of images to be included from the input stack. For instance, RVIPER, if it finds a stable solution, may exclude some images, and thus their projection angles will be excluded from the parameters file. The file containing the list of included images will have a name like main003/index_keep_image.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "ProjMatch - Sampling angle"; + token.help = "Angular-sampling for reference projections. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "ProjMatch - Symmetry"; + token.help = "To limit angular projections. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "partangles"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Alignment parameter file"; + token.help = "Input refinement parameter file, e.g., Refine3D/final_params_037.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "partselect"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Particle selection file"; + token.help = "Input substack selection file if particles removed before refinement, e.g., Substack/isac_substack_particle_id_list.txt. This file is used to map the particle number before classification to particle number in refinement. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "outliers"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Outlier angle"; + token.help = "Particles differing from average Euler angle by more than this threshold (in degrees) will be excluded from average calculation, by default keeps all. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "prjmethod"; + token.key_prefix = "--"; + token.label = "Interpolation method"; + token.help = "Valid choices are trilinear, gridding, and nn. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "trilinear"; + token.restore = [['trilinear', 'gridding', 'nn'], ['trilinear', 'gridding', 'nn']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "display"; + token.key_prefix = "--"; + token.label = "e2display"; + token.help = "Automatically pops up a window with the output montage. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "matchshift"; + token.key_prefix = "--"; + token.label = "ProjMatch - Maximum shift"; + token.help = "Maximum shift to allow during translation alignment, pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "matchrad"; + token.key_prefix = "--"; + token.label = "ProjMatch - Outer radius"; + token.help = "Outer alignment radius, defaults to automatically-determined. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "matchstep"; + token.key_prefix = "--"; + token.label = "ProjMatch - Radius step size"; + token.help = "Alignment radius step size. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "refinerad"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Outer radius"; + token.help = "Outer alignment radius, defaults to automatically-determined. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "refineshift"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Maximum shift"; + token.help = "Maximum shift to allow during translation alignment, pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "refinestep"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Radius step size"; + token.help = "Alignment radius step size. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "align"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Alignment method"; + token.help = "Valid choices are apsh and scf. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "apsh"; + token.restore = [['apsh', 'scf'], ['apsh', 'scf']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_viper"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Initial 3D Model - VIPER"; + sxcmd.short_info = "ab initio 3D structure determination using Validation of Individual Parameter Reproducibility (VIPER). Determines a validated initial model using a small set of class averages produced by ISAC2."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input images stack"; + token.help = "A small subset of class averages produced by ISAC2. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The automatically-created output directory will contain results. If the directory already exists, results will be written there, possibly overwriting previous runs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Use the same value as in ISAC2. It has to be less than half the box size. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the particle. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "moon_elimination"; + token.key_prefix = "--"; + token.label = "Eliminate disconnected regions"; + token.help = "Used to removed disconnected pieces from the model. As an argument it requires a comma-separated string with the mass in KDa and the pixel size in [A]. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ir"; + token.key_prefix = "--"; + token.label = "Inner rotational search radius [Pixels]"; + token.help = "Inner rotational search radius [Pixels]. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rs"; + token.key_prefix = "--"; + token.label = "Ring step size [Pixels]"; + token.help = "Step between rings used for the rotational search. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "X search range [Pixels]"; + token.help = "The translational search range in the x direction. Search will be +/-xr in steps of ts. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "yr"; + token.key_prefix = "--"; + token.label = "Y search range [Pixels]"; + token.help = "The translational search range in the y direction. If omitted, it will be set to xr. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Translational search step [Pixels]"; + token.help = "The search will be performed in -xr, -xr+ts, 0, xr-ts, xr, can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Projection angular step [Degrees]"; + token.help = "Projection angular step, degrees. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center"; + token.key_prefix = "--"; + token.label = "Centering method"; + token.help = "For 3D template, -1: center of coordinates, 0: no centering; 1: center of gravity "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit1"; + token.key_prefix = "--"; + token.label = "Maximum iterations - GA step"; + token.help = "Maximum number of iterations for GA step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "400"; + token.restore = [['400'], ['400']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxit2"; + token.key_prefix = "--"; + token.label = "Maximum iterations - Finish step"; + token.help = "Maximum iterations number of for Finish step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "50"; + token.restore = [['50'], ['50']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask"; + token.help = "Path to 3D mask file. By default, a spherical mask will be used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sphere"; + token.restore = [['sphere'], ['sphere']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "L2threshold"; + token.key_prefix = "--"; + token.label = "GA stop threshold"; + token.help = "Defines the maximum relative dispersion of structures' L2 norms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.03"; + token.restore = [['0.03'], ['0.03']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ref_a"; + token.key_prefix = "--"; + token.label = "Projection generation method"; + token.help = "Method for generating the quasi-uniformly distributed projection directions. S - Saff algorithm, or P - Penczek 1994 algorithm. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S'], ['S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nruns"; + token.key_prefix = "--"; + token.label = "Number of runs"; + token.help = "GA population size, i.e., the number of quasi-independent structures generated. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "6"; + token.restore = [['6'], ['6']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "doga"; + token.key_prefix = "--"; + token.label = "Threshold to start GA"; + token.help = "Do GA when the fraction of orientation that changes less than 1.0 degrees is at least this fraction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [1/Pixels]"; + token.help = "Using a hyperbolic tangent low-pass filter. Specify with absolute frequency. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.25"; + token.restore = [['0.25'], ['0.25']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Fall-off of for the hyperbolic tangent low-pass filter. Specify with absolute frequency. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pwreference"; + token.key_prefix = "--"; + token.label = "Power spectrum reference"; + token.help = "Text file containing a 1D reference power spectrum. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "spectrum1d"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Print debug info. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pdb2em"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "PDB File Conversion"; + sxcmd.short_info = "Converts an atomic model stored in a PDB file into a simulated electron density map."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_pdb"; + token.key_prefix = ""; + token.label = "Input PDB file"; + token.help = "Starting atomic coordinates. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "pdb"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_hdf"; + token.key_prefix = ""; + token.label = "Output map"; + token.help = "Specify file path for output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size of output map [A]"; + token.help = "Pixel size of the output map [A]. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box"; + token.key_prefix = "--"; + token.label = "Output box size [Voxels]"; + token.help = "Specify string of a single value (e.g. '256') to get a cubic box. Alternatively, use 'x,y,z' format to specify demensions of x,y,z-axis (e.g. '128,64,256'). If not given, the program will find the minimum box size fitting the structure. Be aware that this will most likely result in a rectangular box. Note that GUI does not support the default mode. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "het"; + token.key_prefix = "--"; + token.label = "Include hetero atoms"; + token.help = "Otherwise, the HETATM entries in the PDB file are ignored. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chains"; + token.key_prefix = "--"; + token.label = "Chain identifiers"; + token.help = "A string list of chain identifiers to include (e.g. 'ABEFG'). By default, all chains will be included. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center"; + token.key_prefix = "--"; + token.label = "Center model at the origin"; + token.help = "Specifies whether the atomic model should be moved to the origin before generating density map. Available options are: 'c' - Use the geometrical center of atoms; 'a' - Use the center of mass (recommended); 'x,y,z' - Vector to be subtracted from all PDB coordinates. 'n' - No centering, in which case (0,0,0) in the PDB space will map to the center of the EM volume. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "a"; + token.restore = [['a'], ['a']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "O"; + token.key_prefix = "--"; + token.label = "Apply additional rotation"; + token.help = "This can be used to modify the orientation of the atomic model by using O system of coordinates. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "tr0"; + token.key_prefix = "--"; + token.label = "Rotational matrix file"; + token.help = "This file must contain the 3x4 transformation matrix to be applied to the PDB coordinates after centering. The translation vector (last column of the matrix) must be specified in Angstrom. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "rot_matrix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "set_apix_value"; + token.key_prefix = "--"; + token.label = "Set header pixel size"; + token.help = "Set pixel size in header of the ouput map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "quiet"; + token.key_prefix = "--"; + token.label = "Silent mode"; + token.help = "Does not print any information to the monitor. Verbose is the default. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_viper"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Refinement"; + sxcmd.short_info = "Performs 3D structure refinement using a quasi-Maximum Likelihood approach."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Input image stack. Required for new runs, not for restarts. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "initial_volume"; + token.key_prefix = ""; + token.label = "Initial 3D reference"; + token.help = "The 3D reference used in the initial iteration of 3D refinement. Required only for new runs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "initialshifts"; + token.key_prefix = "--"; + token.label = "Read shifts from header"; + token.help = "Start refinement using translation parameters located in the input file header to jumpstart the procedure. Specific to standard run mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = True; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_prealignment"; + token.key_prefix = "--"; + token.label = "Skip the 2D pre-alignment step"; + token.help = "Indicate if pre-alignment should be omitted. By default it is performed in order to find initial translation parameters. This accelerates convergence of the program. Do not use 2D pre-alignment if images are already centered. Specific to standard run modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['initialshifts', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('initialshifts', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "center_method"; + token.key_prefix = "--"; + token.label = "Centering method"; + token.help = "Method for centering averages during initial 2D prealignment of data (0: no centering; -1: average shift method; For 1-7, see center_2D in utilities.py). Specific to standard run modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_radius"; + token.key_prefix = "--"; + token.label = "Target particle radius [Pixels]"; + token.help = "For 2D prealignment, images will be shrunk or enlarged to this radius. Specific to standard run modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "25.0"; + token.restore = [['25.0'], ['25.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_gui_meridien"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Refinement Assessment"; + sxcmd.short_info = "GUI tool to assess 3D Refinement based on outputs of sp_meridien."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = False + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sxresolution"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compute mFSC"; + sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "Volume #1"; + token.help = "First unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Volume #2"; + token.help = "Second unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maskfile"; + token.key_prefix = ""; + token.label = "3D mask"; + token.help = "Defines the region within which FSCM will be computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputdir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where output files will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Mask radius"; + token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) + token = SXcmd_token(); + token.key_base = "wn"; + token.key_prefix = "--"; + token.label = "Window size"; + token.help = "Size of window within which local real-space FSC is computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "15"; + token.restore = [['15'], ['15']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "local_fsc"; + token.key_prefix = "--"; + token.label = "Compute local resolution"; + token.help = "Set to 1 to compute local resolution volume. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0', '1'], ['0', '1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sigmag"; + token.key_prefix = "--"; + token.label = "Sigma of Gaussian window"; + token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Shell step"; + token.help = "Shell step in Fourier size in pixels (integer). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "lfi"; + token.key_prefix = "--"; + token.label = "Inner radius"; + token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hfi"; + token.key_prefix = "--"; + token.label = "Outer radius"; + token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "significance"; + token.key_prefix = "--"; + token.label = "Significance level"; + token.help = "Significance level for the upper confidence interval "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.99"; + token.restore = [['0.99'], ['0.99']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndf_reduce"; + token.key_prefix = "--"; + token.label = "Number of asymmetric units"; + token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cutoff"; + token.key_prefix = "--"; + token.label = "FSC criterion"; + token.help = "Resolution cut-off for FSCM confidence interval. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.143"; + token.restore = [['0.143'], ['0.143']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nthreads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "Number of threads (mainly for 3D FFT). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "combinemaps"; + sxcmd.subset_config = "halfset maps"; + sxcmd.label = "PostRefiner"; + sxcmd.short_info = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "combinemaps"; + token.key_prefix = "--"; + token.label = "Post-refine halfset volumes"; + token.help = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "First unfiltered halfset map"; + token.help = "As generated by sxmeridien."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Second unfiltered halfset map"; + token.help = "As generated by sxmeridien."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of input data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "Path to user-provided mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "do_adaptive_mask"; + token.key_prefix = "--"; + token.label = "Apply adaptive mask"; + token.help = "Program creates mask adaptively with given density threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "-9999.0"; + token.restore = [['-9999.0'], ['-9999.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "do_approx"; + token.key_prefix = "--"; + token.label = "Approximate values"; + token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mtf"; + token.key_prefix = "--"; + token.label = "MTF file"; + token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mtf"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fsc_adj"; + token.key_prefix = "--"; + token.label = "Apply FSC-based low-pass filter"; + token.help = "Applies an FSC-based low-pass filter to the merged map before the B-factor estimation. Effective only in Halfset Volumes Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_enhance"; + token.key_prefix = "--"; + token.label = "B-factor enhancement"; + token.help = "0.0: program automatically estimates B-factor using power spectrum at frequencies from B_start (usually 10 Angstrom) to the resolution determined by FSC143 (valid only in Halfset Volumes Mode; Non-zero positive value: program use the given value [A^2] to enhance map); -1.0: B-factor is not applied. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_start"; + token.key_prefix = "--"; + token.label = "B-factor estimation lower limit [A]"; + token.help = "Frequency in Angstrom defining lower boundary of B-factor estimation. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) + token = SXcmd_token(); + token.key_base = "B_stop"; + token.key_prefix = "--"; + token.label = "B-factor estimation upper limit [A]"; + token.help = "Frequency in Angstrom defining upper boundary of B-factor estimation. Recommended to set the upper boundary to the frequency where FSC is smaller than 0.0. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [A]"; + token.help = "0.0: low-pass filter to resolution (valid only in Halfset Volumes Mode); A value larger than 0.5: low-pass filter to the value in Angstrom; -1.0: no low-pass filter. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "output"; + token.key_prefix = "--"; + token.label = "Output file name"; + token.help = "File name of output final post-refined structure. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol_combined.hdf"; + token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sxresolution"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compute mFSC"; + sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "Volume #1"; + token.help = "First unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Volume #2"; + token.help = "Second unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maskfile"; + token.key_prefix = ""; + token.label = "3D mask"; + token.help = "Defines the region within which FSCM will be computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputdir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where output files will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Mask radius"; + token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) + token = SXcmd_token(); + token.key_base = "wn"; + token.key_prefix = "--"; + token.label = "Window size"; + token.help = "Size of window within which local real-space FSC is computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "15"; + token.restore = [['15'], ['15']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "local_fsc"; + token.key_prefix = "--"; + token.label = "Compute local resolution"; + token.help = "Set to 1 to compute local resolution volume. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0', '1'], ['0', '1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sigmag"; + token.key_prefix = "--"; + token.label = "Sigma of Gaussian window"; + token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Shell step"; + token.help = "Shell step in Fourier size in pixels (integer). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "lfi"; + token.key_prefix = "--"; + token.label = "Inner radius"; + token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hfi"; + token.key_prefix = "--"; + token.label = "Outer radius"; + token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "significance"; + token.key_prefix = "--"; + token.label = "Significance level"; + token.help = "Significance level for the upper confidence interval "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.99"; + token.restore = [['0.99'], ['0.99']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndf_reduce"; + token.key_prefix = "--"; + token.label = "Number of asymmetric units"; + token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cutoff"; + token.key_prefix = "--"; + token.label = "FSC criterion"; + token.help = "Resolution cut-off for FSCM confidence interval. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.143"; + token.restore = [['0.143'], ['0.143']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nthreads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "Number of threads (mainly for 3D FFT). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_header"; + sxcmd.subname = ""; + sxcmd.mode = "import"; + sxcmd.subset_config = ""; + sxcmd.label = "Import Projection Parameters"; + sxcmd.short_info = "Import projection orientation parameters to the header of the input stack. (Five columns: phi, theta, pshi, sx, sy). These parameters are required by 'Local Refinement from Stack' mode."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "import"; + token.key_prefix = "--"; + token.label = "Import parameters"; + token.help = "Import parameters from file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params"; + token.key_prefix = "--"; + token.label = "Target parameters"; + token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [['xform.projection'], ['xform.projection']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "local_refinement"; + sxcmd.subset_config = "stack"; + sxcmd.label = "Local Refinement from Stack"; + sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "local_refinement"; + token.key_prefix = "--"; + token.label = "Perform local refinement"; + token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [[-1.0], [-1.0]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "local_refinement"; + sxcmd.subset_config = "iteration"; + sxcmd.label = "Restart Local Refinement"; + sxcmd.short_info = "Restart local refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same as in the original run."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "local_refinement"; + token.key_prefix = "--"; + token.label = "Perform local refinement"; + token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Directory"; + token.help = "This directory must exist. The results will be written there."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [[-1.0], [-1.0]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = "restart"; + sxcmd.label = "3D Refinement Restart"; + sxcmd.short_info = "Restart 3D refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Output Directory"; + token.help = "This directory must exist. The results will be written here."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "25.0"; + token.restore = [['25.0'], ['25.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "do_final"; + sxcmd.subset_config = ""; + sxcmd.label = "Final 3D Reconstruction Only"; + sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "do_final"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Output Directory"; + token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien_alpha"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = "beta"; + sxcmd.label = "3D Refinement (Alpha)"; + sxcmd.short_info = "Performs 3D structure refinement for helical specimen using a quasi-Maximum Likelihood approach."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Input image stack. Required for new runs, not for restarts. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "initial_volume"; + token.key_prefix = ""; + token.label = "Initial 3D reference"; + token.help = "The 3D reference used in the initial iteration of 3D refinement. Required only for new runs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "initialshifts"; + token.key_prefix = "--"; + token.label = "Read shifts from header"; + token.help = "Start refinement using translation parameters located in the input file header to jumpstart the procedure. Specific to standard run mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = True; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_prealignment"; + token.key_prefix = "--"; + token.label = "Skip the 2D pre-alignment step"; + token.help = "Indicate if pre-alignment should be omitted. By default it is performed in order to find initial translation parameters. This accelerates convergence of the program. Do not use 2D pre-alignment if images are already centered. Specific to standard run modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['initialshifts', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('initialshifts', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "center_method"; + token.key_prefix = "--"; + token.label = "Centering method"; + token.help = "Method for centering averages during initial 2D prealignment of data (0: no centering; -1: average shift method; For 1-7, see center_2D in utilities.py). Specific to standard run modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_radius"; + token.key_prefix = "--"; + token.label = "Target particle radius [Pixels]"; + token.help = "For 2D prealignment, images will be shrunk or enlarged to this radius. Specific to standard run modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "29"; + token.restore = [['29'], ['29']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "25.0"; + token.restore = [['25.0'], ['25.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta_min"; + token.key_prefix = "--"; + token.label = "Theta min [degree]"; + token.help = "Minimum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta_max"; + token.key_prefix = "--"; + token.label = "Theta max [degree]"; + token.help = "Maximum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "angle_method"; + token.key_prefix = "--"; + token.label = "Even angle method"; + token.help = "Method to use for even angle creation (S, M, P). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk_by"; + token.key_prefix = "--"; + token.label = "Group name for chunks"; + token.help = "Group the particles by the specified header name before splitting them into chunks. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "ptcl_source_image"; + token.restore = [['ptcl_source_image'], ['filament_id']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_by"; + token.key_prefix = "--"; + token.label = "Outlier group ID"; + token.help = "Group the particles by the header name for outlier detection. By default do not perform outlier detection. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['filament_id']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [px]"; + token.help = "This is used to normalize the particles in case of filaments. A rectangular mask will be used instead of a circular one. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "helical_rise"; + token.key_prefix = "--"; + token.label = "Helical rise [A]"; + token.help = "Helical rise used to limit the shift along the helical axis to +-rise/2 "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "plot_ang_dist"; + token.key_prefix = "--"; + token.label = "Plot angular distribution"; + token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_tracker"; + token.key_prefix = "--"; + token.label = "Outlier Tracker"; + token.help = "Tracker from a previous MERIDIEN directory that ran with the same stack to skip the OUTLIER finding. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_json"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "howmany"; + token.key_prefix = "--"; + token.label = "Howmany value"; + token.help = "Howmany neighbors shouls be taken into account for the exhaustive step of the refinementHowmany neighbors shouls be taken into account for the exhaustive step of the refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien_alpha"; + sxcmd.subname = ""; + sxcmd.mode = "local_refinement"; + sxcmd.subset_config = "iteration_beta"; + sxcmd.label = "Restart Local Refinement (Beta)"; + sxcmd.short_info = "Restart local refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same as in the original run."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "local_refinement"; + token.key_prefix = "--"; + token.label = "Perform local refinement"; + token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Directory"; + token.help = "This directory must exist. The results will be written there."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [[-1.0], [-1.0]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta_min"; + token.key_prefix = "--"; + token.label = "Theta min [degree]"; + token.help = "Minimum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "theta_max"; + token.key_prefix = "--"; + token.label = "Theta max [degree]"; + token.help = "Maximum out-of-plane rotation value to use for the reference projection angles. Default is the full range from 0 to 180. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['90']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "angle_method"; + token.key_prefix = "--"; + token.label = "Even angle method"; + token.help = "Method to use for even angle creation (S, M, P). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk_by"; + token.key_prefix = "--"; + token.label = "Group name for chunks"; + token.help = "Group the particles by the specified header name before splitting them into chunks. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "ptcl_source_image"; + token.restore = [['ptcl_source_image'], ['filament_id']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_by"; + token.key_prefix = "--"; + token.label = "Outlier group ID"; + token.help = "Group the particles by the header name for outlier detection. By default do not perform outlier detection. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['filament_id']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filament_width"; + token.key_prefix = "--"; + token.label = "Filament width [px]"; + token.help = "This is used to normalize the particles in case of filaments. A rectangular mask will be used instead of a circular one. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "filament_width"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "helical_rise"; + token.key_prefix = "--"; + token.label = "Helical rise [A]"; + token.help = "Helical rise used to limit the shift along the helical axis to +-rise/2 "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "plot_ang_dist"; + token.key_prefix = "--"; + token.label = "Plot angular distribution"; + token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outlier_tracker"; + token.key_prefix = "--"; + token.label = "Outlier Tracker"; + token.help = "Tracker from a previous MERIDIEN directory that ran with the same stack to skip the OUTLIER finding. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_json"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "howmany"; + token.key_prefix = "--"; + token.label = "Howmany value"; + token.help = "Howmany neighbors shouls be taken into account for the exhaustive step of the refinementHowmany neighbors shouls be taken into account for the exhaustive step of the refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien_alpha"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = "restart_beta"; + sxcmd.label = "3D Refinement Restart (Beta)"; + sxcmd.short_info = "Restart 3D refinement after the last fully finished iteration of meridien run or local refinement run. One can change some parameters, but MPI settings have to be the same."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Output Directory"; + token.help = "This directory must exist. The results will be written here."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial map used to start the refinement. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "25.0"; + token.restore = [['25.0'], ['25.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "plot_ang_dist"; + token.key_prefix = "--"; + token.label = "Plot angular distribution"; + token.help = "Plot the angular distribution in every iteration. This will take some time for high symmetries."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien_alpha"; + sxcmd.subname = ""; + sxcmd.mode = "do_final"; + sxcmd.subset_config = ""; + sxcmd.label = "Final 3D Reconstruction Only (Beta)"; + sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "do_final"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Output Directory"; + token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "balance_angular_distribution"; + sxcmd.subset_config = ""; + sxcmd.label = "Balance Angular Distribution"; + sxcmd.short_info = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "balance_angular_distribution"; + token.key_prefix = "--"; + token.label = "Balance Angular Distribution"; + token.help = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_any_txt"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "Typically from MERIDIEN with a filename in the form of Refine3D/final_params_0##.txt"; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Output selection list"; + token.help = "Text file with a list of retained particle images"; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "max_occupy"; + token.key_prefix = "--"; + token.label = "Maximum orientations per reference angle"; + token.help = "Maximum number of particles per reference angle. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "angstep"; + token.key_prefix = "--"; + token.label = "Angular increment"; + token.help = "Angular step of reference angles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "15"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "angular step of reference angles, i.e., number of bins of angular histogram. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "meridien"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Meridien)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "refinement_dir"; + token.key_prefix = ""; + token.label = "Meridien directory"; + token.help = "Path to Meridien directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "manual"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Stack)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume_path"; + token.key_prefix = ""; + token.label = "Path to volume"; + token.help = "Path to volume. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Params file"; + token.help = "Path to params file "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk"; + token.key_prefix = "--"; + token.label = "Path to chunk file"; + token.help = "Path to chunk file "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume2"; + token.key_prefix = "--"; + token.label = "Path to second volume"; + token.help = "Path to second half volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_higher_ord_abber"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Relion CTF Refinement"; + sxcmd.short_info = "Apply relion ctf refinement for higher order aberration correction"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "post_refine_folder"; + token.key_prefix = ""; + token.label = "Post Refine Folder"; + token.help = "Input folder is the directory where the results of the post refiner are present and python routine automatically locates all the required files used for ctf refinement. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output folder"; + token.help = "Output folder is the directory where all the results of the ctf refinement are saved. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "estimate_magnification"; + token.key_prefix = "--"; + token.label = "Estimate (anisotropic) magnification"; + token.help = "Estimate magnification of dataset . "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "estimate_beamtilt"; + token.key_prefix = "--"; + token.label = "Estimate beamtilt"; + token.help = "Estimate beamtilt from the dataset. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "estimate_trefoil"; + token.key_prefix = "--"; + token.label = "Also estimate trefoil"; + token.help = "estimate 3-fold astigmatism per optics group ."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "estimate_order_aberation"; + token.key_prefix = "--"; + token.label = "Estimate the 4th order aberrations"; + token.help = "Estimate the 4th order aberation ."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "perform_CTF_params_fit"; + token.key_prefix = "--"; + token.label = "Perform CTF parameter fitting"; + token.help = "Perform CTF parameter fitting. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "fit_defocus_micrograph"; + token.key_prefix = "--"; + token.label = "Fit defocus based on micrographs"; + token.help = "Fit defocus based on micrographs. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_defocus_particle"; + token.key_prefix = "--"; + token.label = "Fit defocus based on particles"; + token.help = "Fit defocus based on particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_astigmatism_micrograph"; + token.key_prefix = "--"; + token.label = "Fit astigmatism based on micrographs"; + token.help = "Fit astigmatism based on micrographs ."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_astigmatism_particle"; + token.key_prefix = "--"; + token.label = "Fit astigmatism based on particles"; + token.help = "Fit astigmatism based on particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_bfactor_micrograph"; + token.key_prefix = "--"; + token.label = "Fit bfactor based on micrographs"; + token.help = "Fit bfactor based on micrographs. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_bfactor_particle"; + token.key_prefix = "--"; + token.label = "Fit bfactor based on particles"; + token.help = "Fit bfactor based on particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_phase_shift_micrograph"; + token.key_prefix = "--"; + token.label = "Fit phase shift estimation for micrographs"; + token.help = "Fit phase shift estimation for micrographs ."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fit_phase_shift_particle"; + token.key_prefix = "--"; + token.label = "Fit phase shift estimation for particles"; + token.help = "Fit phase shift estimation for particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['estimate_magnification', 'False', 'False'], + ['perform_CTF_params_fit', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('estimate_magnification', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('perform_CTF_params_fit', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "min_res_fit"; + token.key_prefix = "--"; + token.label = "minimum resolution value for fitting (A)"; + token.help = "minimum resolution value for fitting "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "30.0"; + token.restore = [['30.0'], ['30.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "submission_template"; + token.key_prefix = "--"; + token.label = "Submission template"; + token.help = "Submission template for mpi command "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "submission_temp"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = "--"; + token.label = "Submission command"; + token.help = "Submission commmand for cluster "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sbatch "; + token.restore = [['sbatch ', ' qsub ', ' bash'], ['sbatch ', ' qsub ', ' bash']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_mpirun_executable"; + token.key_prefix = "--"; + token.label = "relion mpirun executable"; + token.help = "Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "mpirun"; + token.restore = [['mpirun'], ['mpirun']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_ctfrefine_executable"; + token.key_prefix = "--"; + token.label = "relion ctf refine executable"; + token.help = "Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion ctf refine executable also for that just type which relion_ctf_refine_mpi and copy the path here. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "relion_ctf_refine_mpi"; + token.restore = [['relion_ctf_refine_mpi'], ['relion_ctf_refine_mpi']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_procs"; + token.key_prefix = "--"; + token.label = "MPI Procs"; + token.help = "The number of MPI processors used for Relion multiprocessing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_of_threads"; + token.key_prefix = "--"; + token.label = "number of threads"; + token.help = "The number of threads use during the ctf refinement. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mrc_reloc_folder"; + token.key_prefix = "--"; + token.label = "mrc relocation folder"; + token.help = "In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_polishing"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Relion Polishing"; + sxcmd.short_info = "Apply relion polishing on SPHIRE generated stacks"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_meridien"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "post_refine_folder"; + token.key_prefix = ""; + token.label = "Post Refine Folder"; + token.help = "Input folder is the directory where the results of the post refiner are present. Python routine automatically locates all the required files used for polishing. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "motioncorr_starfile"; + token.key_prefix = ""; + token.label = "MotionCorr Starfile"; + token.help = "MotionCorr generated star file which normally is saved as corrected_micrographs.star "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output folder"; + token.help = "Output folder is the directory where all the results of the polishing are saved. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "training_params"; + token.key_prefix = "--"; + token.label = "training params"; + token.help = "In case if the user wants to do the training part of the polishing then this is None. Otherwise provide the optimize_params.txt file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "min_no_particles"; + token.key_prefix = "--"; + token.label = "Minimum no of particles"; + token.help = "Number of particles to inlcude for training. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['training_params', 'none', 'False']]; + token.default = "5000"; + token.restore = [['5000'], ['5000']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('training_params', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "submission_template"; + token.key_prefix = "--"; + token.label = "Submission template"; + token.help = "Submission template for mpi command "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "submission_temp"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = "--"; + token.label = "Submission command"; + token.help = "Submission commmand for cluster "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sbatch "; + token.restore = [['sbatch ', ' qsub ', ' bash'], ['sbatch ', ' qsub ', ' bash']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_mpirun_executable"; + token.key_prefix = "--"; + token.label = "relion mpirun executable"; + token.help = "Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "mpirun"; + token.restore = [['mpirun'], ['mpirun']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_polishing_executable"; + token.key_prefix = "--"; + token.label = "relion polishing executable"; + token.help = "Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion polishing executable also. Just type which relion_motion_refine_mpi and copy the path here. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "relion_motion_refine_mpi"; + token.restore = [['relion_motion_refine_mpi'], ['relion_motion_refine_mpi']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_procs"; + token.key_prefix = "--"; + token.label = "relion MPI Procs"; + token.help = "The number of MPI processors used for Relion multiprocessing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['training_params', 'none', 'True']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('training_params', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "no_of_threads"; + token.key_prefix = "--"; + token.label = "relion number of threads"; + token.help = "The number of threads use during the polishing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_frame"; + token.key_prefix = "--"; + token.label = "first frame [number]"; + token.help = "The 1st frame number from where it should start. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "last_frame"; + token.key_prefix = "--"; + token.label = "last frame [number]"; + token.help = "The last frame number where it should end. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "bfac_minfreq"; + token.key_prefix = "--"; + token.label = "minimum resolution for B-factor fit [A]"; + token.help = "The minimum frequency range which is normally the maximum inner shell to include in enhancement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "20"; + token.restore = [['20'], ['20']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "bfac_maxfreq"; + token.key_prefix = "--"; + token.label = "maximum resolution for B-factor fit [A]"; + token.help = "The minimum frequency range which is normally the maximum outer shell to include in enhancement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mrc_reloc_folder"; + token.key_prefix = "--"; + token.label = "mrc relocation folder"; + token.help = "In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_header"; + sxcmd.subname = ""; + sxcmd.mode = "import"; + sxcmd.subset_config = ""; + sxcmd.label = "Import Projection Parameters"; + sxcmd.short_info = "Import projection orientation parameters from a file (for example created by sxmeridien) to header of the input stack; they are required by 3DVARIABILITY.py and SORT3D_DEPTH Stack Mode."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "import"; + token.key_prefix = "--"; + token.label = "Import parameters"; + token.help = "Import parameters from file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params"; + token.key_prefix = "--"; + token.label = "Target parameters"; + token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [['xform.projection'], ['xform.projection']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_3dvariability"; + sxcmd.subname = ""; + sxcmd.mode = "symmetrize"; + sxcmd.subset_config = ""; + sxcmd.label = "3D Variability Preprocess"; + sxcmd.short_info = "Prepare input stack for handling symmetry. Please skip this preparation step if the structure is asymmetrical (i.e. c1), since it is required only when the structure has internal symmetry. Notice this step can be run with only one CPU and there is no MPI version for it. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "symmetrize"; + token.key_prefix = "--"; + token.label = "Symmetrise input stack"; + token.help = "Prepare input stack for handling symmetry. Please skip this preparation step if the structure is asymmetrical (i.e. c1), since it is required only when the structure has internal symmetry. Notice this step can be run with only one CPU and there is no MPI version for it. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prj_stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "The images must contain the 3D orientation parameters in headers and optionally also CTF information. The output image stack is bdb:sdata. Please use it as an input image stack of sx3dvariability."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory of 3D Variability. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "If the structure has symmetry higher than c1, the command requires symmetrization of the dataset, using --symmetrize option, before computing 3D variability. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_3dvariability"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Variability Estimation"; + sxcmd.short_info = "Calculate 3D variability using a set of aligned projection images as an input."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "prj_stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "The images must containt the 3D orientation parameters in the header and optionally CTF information. If the structure has a symmetry higher than c1, please specify the image stack which is prepared by the symmetrization using --symmetrize option. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory of 3D Variability. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "var3D"; + token.key_prefix = "--"; + token.label = "Output 3D variability"; + token.help = "Specify a file name to indicate if the program should write the reconstructed 3D variability map to the disk. The 3D volume will contain, for each voxel, a measure of the variability in the dataset. Careful, time consuming! "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ave3D"; + token.key_prefix = "--"; + token.label = "Output 3D average"; + token.help = "Specify a file name to indicate if the program should write the reconstructed 3D average map to the disk. The 3D map will be reconstructed from projections averaged within respective angular neighbourhood. It should be used to assess the resolvability and possible artifacts of the variability map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp"; + token.key_prefix = "--"; + token.label = "Number of projections"; + token.help = "Specify the number of images from the angular neighbourhood that will be used to estimate 2D variance for each projection data. The larger the number the less noisy the estimate, but the lower the resolution. Usage of large number also results in rotational artifacts in variances that will be visible in 3D variability map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "If the structure has symmetry higher than c1, the command requires symmetrization of the dataset, using --symmetrize option, before computing 3D variability. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "CTF"; + token.key_prefix = "--"; + token.label = "Use CTF correction"; + token.help = "If set to true, CTF correction will be applied using the parameters found in the image headers. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = True; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overhead"; + token.key_prefix = "--"; + token.label = "Python overhead memory"; + token.help = "User estimates python overhead memory per CPU. The default value is 0.5 GB per CPU. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "var2D"; + token.key_prefix = "--"; + token.label = "Output 2D variances"; + token.help = "Specify a file name to indicate if the program should write the stack of computed 2D variances to the disk. Useful for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ave2D"; + token.key_prefix = "--"; + token.label = "Output 2D averages"; + token.help = "Specify a file name to indicate if the program should write the stack of computed 2D averages to the disk. Useful for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "VAR"; + token.key_prefix = "--"; + token.label = "Input stack consists of 2D variances"; + token.help = "Stack on input consists of 2D variances. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_norm"; + token.key_prefix = "--"; + token.label = "Apply normalization"; + token.help = "Indicate if normalization should be applied or not. By default, apply normalization. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "npad"; + token.key_prefix = "--"; + token.label = "Image padding factor"; + token.help = "The number of time to pad the original images. The images will be padded to achieve the original size times this option. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "decimate"; + token.key_prefix = "--"; + token.label = "Image decimate factor"; + token.help = "Reduce images by this factor and change the pixel size. Specify a non-zero positive float value smaller than 1.0. By default, it does not change size of images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.25"; + token.restore = [['0.25'], ['0.25']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency"; + token.help = "Stop-band frequency of the low-pass filter to be applied to the images prior to variability calculation but after decimation. Specify it in absolute frequency (> 0.0 and <= 0.5). By default, no filtering. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "abs_freq"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off"; + token.help = "Fall-off width of the low-pass filter to be applied to the images prior to variability calculation but after decimation. Specify it in absolute frequency (> 0.0 and <= 0.5). 0.01 works in most of cases. Effective only with --fl > 0.0 and --aa > 0.0 has to be specified. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '0.0', 'True']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '0.0', 'True']) + token = SXcmd_token(); + token.key_base = "window"; + token.key_prefix = "--"; + token.label = "Target image size [Pixels]"; + token.help = "Window (or clip) images using the specified size without changing pixel size. It is relative to the orignal window size. The target window size cannot be larger than the orignal image size. By default, use the original particle image size. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nvec"; + token.key_prefix = "--"; + token.label = "Number of eigenvectors"; + token.help = "By default, no PCA will be calculated. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_sort3d_depth"; + sxcmd.subname = ""; + sxcmd.mode = "refinement_dir"; + sxcmd.subset_config = ""; + sxcmd.label = "3D Clustering from Iteration - SORT3D_DEPTH"; + sxcmd.short_info = "Initialize from a given iteration of meridien run using the associated parameters, i.e., full set of orientation parameters per image, including orientation probabilities, normalizations and so on."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "refinement_dir"; + token.key_prefix = "--"; + token.label = "Meridien refinement directory"; + token.help = "A string denotes meridien 3D refinement directory. Sorting switches to meridien iteration mode when specified. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "A string denotes output directory for 3D sorting. It can be either existing or non-existing. By default, the program uses sort3d_DATA_AND_TIME for the name. Here, you can find a log.txt that describes the sequences of computations in the program. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "niter_for_sorting"; + token.key_prefix = "--"; + token.label = "Iteration ID of 3D refinement for importing data"; + token.help = "By default, the program uses the iteration at which refinement achieved the best resolution. Option is valid only for meridien iteration mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask"; + token.help = "A string denotes file path of the global 3D mask for clustering. Imported from 3D refinement unless user wishes a different one in meridien iteration mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "focus"; + token.key_prefix = "--"; + token.label = "Focus 3D mask"; + token.help = "A string denotes file path of a binary 3D mask for focused clustering. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Estimated particle radius [Pixels]"; + token.help = "A integer value that is smaller than half of the box size. Imported from refinement unless user wishes a different one in meridien iteration mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "A string denotes point group symmetry of the macromolecular structure. Imported from refinement unless the user wishes a different one in meridien iteration mode. Require specification in stack mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp"; + token.key_prefix = "--"; + token.label = "Number of images per group"; + token.help = "User expected group size in integer. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1000"; + token.restore = [['1000'], ['1000']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp_split_rate"; + token.key_prefix = "--"; + token.label = "Group splitting rate"; + token.help = "An integer value denotes split rate of the group size(--img_per_grp). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "minimum_grp_size"; + token.key_prefix = "--"; + token.label = "Minimum size of reproducible class"; + token.help = "The minimum size of selected or accounted clusters as well as the minimum group size constraint in MGSKmeans. However this value must be smaller than the number of images per a group (img_per_grp). By default, the program uses half number of the images per group. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "do_swap_au"; + token.key_prefix = "--"; + token.label = "Swap flag"; + token.help = "A boolean flag to control random swapping a certain number of accounted elements per cluster with the unaccounted elements. If the processing with the default values are extremely slow or stalled, please use this --do_swap_au option and set --swap_ratio to a large value (15.0[%] is a good start point). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "swap_ratio"; + token.key_prefix = "--"; + token.label = "Swap percentage [%]"; + token.help = "the percentage of images for swapping ranges between 0.0[%] and 50.0[%]. Option valid only with --do_swap_au. Without --do_swap_au, the program automatically sets --swap_ratio to 0.0. If the processing with the default values are extremely slow or stalled, please use --do_swap_au and set this --swap_ratio option to a large value (15.0[%] is a good start point). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). It will be used to evaluate the number of CPUs per node from user-provided MPI setting. By default, it uses 2GB * (number of CPUs per node). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "depth_order"; + token.key_prefix = "--"; + token.label = "Depth order"; + token.help = "An integer value defines the number of initial independent MGSKmeans runs (2^depth_order). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stop_mgskmeans_percentage"; + token.key_prefix = "--"; + token.label = "Image assignment percentage to stop MGSKmeans [%]"; + token.help = "A floating number denotes particle assignment change percentage that serves as the converge criteria of minimum group size K-means. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nsmear"; + token.key_prefix = "--"; + token.label = "Number of smears for sorting"; + token.help = "Fill it with 1 if user does not want to use all smears. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "orientation_groups"; + token.key_prefix = "--"; + token.label = "Number of orientation groups"; + token.help = "Number of orientation groups in an asymmetric unit. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "not_include_unaccounted"; + token.key_prefix = "--"; + token.label = "Do unaccounted reconstruction"; + token.help = "Do not reconstruct unaccounted elements in each generation. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "notapplybckgnoise"; + token.key_prefix = "--"; + token.label = "Use background noise flag"; + token.help = "Flag to turn off background noise. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "random_group_elimination_threshold"; + token.key_prefix = "--"; + token.label = "Random group elimination threshold"; + token.help = "A floating value denotes the random group reproducibility standard deviation for eliminating random groups. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2bdb"; + sxcmd.subname = ""; + sxcmd.mode = "makevstack"; + sxcmd.subset_config = "subset"; + sxcmd.label = "SORT3D_DEPTH Stack Subset"; + sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "makevstack"; + token.key_prefix = "--"; + token.label = "Output stack subset"; + token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_bdb_stack_file"; + token.key_prefix = ""; + token.label = "Original image stack"; + token.help = "Specify path to input BDB stack file used for the associated SORT3D_DEPTH run."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Image selection file"; + token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual BDB image stack from an existed stack or virtual stack. Typically, Cluster#.txt created by sxsort3d_depth (e.g. Cluster1.txt)."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "local_refinement"; + sxcmd.subset_config = "stack"; + sxcmd.label = "Local Refinement from Stack"; + sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "local_refinement"; + token.key_prefix = "--"; + token.label = "Perform local refinement"; + token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [[-1.0], [-1.0]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "combinemaps"; + sxcmd.subset_config = "halfset maps"; + sxcmd.label = "PostRefiner"; + sxcmd.short_info = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "combinemaps"; + token.key_prefix = "--"; + token.label = "Post-refine halfset volumes"; + token.help = "Post-refine a pair of unfiltered odd & even halfset maps by combining them, then enhancing the high frequencies (Halfset Maps Mode). B-factor can be automatically estimated from the unfiltered halfset maps. This mode requires two arguments; use unfiltered halfset maps produced by MERIDIEN."; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "First unfiltered halfset map"; + token.help = "As generated by sxmeridien."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Second unfiltered halfset map"; + token.help = "As generated by sxmeridien."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of input data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "Path to user-provided mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "do_adaptive_mask"; + token.key_prefix = "--"; + token.label = "Apply adaptive mask"; + token.help = "Program creates mask adaptively with given density threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "-9999.0"; + token.restore = [['-9999.0'], ['-9999.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "do_approx"; + token.key_prefix = "--"; + token.label = "Approximate values"; + token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mtf"; + token.key_prefix = "--"; + token.label = "MTF file"; + token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mtf"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fsc_adj"; + token.key_prefix = "--"; + token.label = "Apply FSC-based low-pass filter"; + token.help = "Applies an FSC-based low-pass filter to the merged map before the B-factor estimation. Effective only in Halfset Volumes Mode. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_enhance"; + token.key_prefix = "--"; + token.label = "B-factor enhancement"; + token.help = "0.0: program automatically estimates B-factor using power spectrum at frequencies from B_start (usually 10 Angstrom) to the resolution determined by FSC143 (valid only in Halfset Volumes Mode; Non-zero positive value: program use the given value [A^2] to enhance map); -1.0: B-factor is not applied. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_start"; + token.key_prefix = "--"; + token.label = "B-factor estimation lower limit [A]"; + token.help = "Frequency in Angstrom defining lower boundary of B-factor estimation. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) + token = SXcmd_token(); + token.key_base = "B_stop"; + token.key_prefix = "--"; + token.label = "B-factor estimation upper limit [A]"; + token.help = "Frequency in Angstrom defining upper boundary of B-factor estimation. Recommended to set the upper boundary to the frequency where FSC is smaller than 0.0. Effective only in Halfset Volumes Mode with --B_enhance=0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['B_enhance', '0.0', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('B_enhance', []).append([token.key_base, '0.0', 'False']) + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [A]"; + token.help = "0.0: low-pass filter to resolution (valid only in Halfset Volumes Mode); A value larger than 0.5: low-pass filter to the value in Angstrom; -1.0: no low-pass filter. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "output"; + token.key_prefix = "--"; + token.label = "Output file name"; + token.help = "File name of output final post-refined structure. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol_combined.hdf"; + token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_sort3d_depth"; + sxcmd.subname = ""; + sxcmd.mode = "instack"; + sxcmd.subset_config = ""; + sxcmd.label = "3D Clustering from Stack - SORT3D_DEPTH"; + sxcmd.short_info = "Run from user-provided orientation parameters stored in stack header. This mode uses only highest probability orientation parameters per image, ths it should be avoided. This program is used only for testing."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "instack"; + token.key_prefix = "--"; + token.label = "Input images stack"; + token.help = "A string denotes file path of input particle stack for sorting. Sorting switches to stack mode when option is specified. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "A string denotes output directory for 3D sorting. It can be either existing or non-existing. By default, the program uses sort3d_DATA_AND_TIME for the name. Here, you can find a log.txt that describes the sequences of computations in the program. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nxinit"; + token.key_prefix = "--"; + token.label = "Initial image size"; + token.help = "Image size used for MGSKmeans in case of starting sorting from a data stack. By default, the program determines window size. Option is valid only for stack mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask"; + token.help = "A string denotes file path of the global 3D mask for clustering. Imported from 3D refinement unless user wishes a different one in meridien iteration mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "focus"; + token.key_prefix = "--"; + token.label = "Focus 3D mask"; + token.help = "A string denotes file path of a binary 3D mask for focused clustering. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Estimated particle radius [Pixels]"; + token.help = "A integer value that is smaller than half of the box size. Imported from refinement unless user wishes a different one in meridien iteration mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "A string denotes point group symmetry of the macromolecular structure. Imported from refinement unless the user wishes a different one in meridien iteration mode. Require specification in stack mode. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp"; + token.key_prefix = "--"; + token.label = "Number of images per group"; + token.help = "User expected group size in integer. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1000"; + token.restore = [['1000'], ['1000']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "img_per_grp_split_rate"; + token.key_prefix = "--"; + token.label = "Group splitting rate"; + token.help = "An integer value denotes split rate of the group size(--img_per_grp). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "minimum_grp_size"; + token.key_prefix = "--"; + token.label = "Minimum size of reproducible class"; + token.help = "The minimum size of selected or accounted clusters as well as the minimum group size constraint in MGSKmeans. However this value must be smaller than the number of images per a group (img_per_grp). By default, the program uses half number of the images per group. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "do_swap_au"; + token.key_prefix = "--"; + token.label = "Swap flag"; + token.help = "A boolean flag to control random swapping a certain number of accounted elements per cluster with the unaccounted elements. If the processing with the default values are extremely slow or stalled, please use this --do_swap_au option and set --swap_ratio to a large value (15.0[%] is a good start point). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "swap_ratio"; + token.key_prefix = "--"; + token.label = "Swap percentage [%]"; + token.help = "the percentage of images for swapping ranges between 0.0[%] and 50.0[%]. Option valid only with --do_swap_au. Without --do_swap_au, the program automatically sets --swap_ratio to 0.0. If the processing with the default values are extremely slow or stalled, please use --do_swap_au and set this --swap_ratio option to a large value (15.0[%] is a good start point). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). It will be used to evaluate the number of CPUs per node from user-provided MPI setting. By default, it uses 2GB * (number of CPUs per node). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "depth_order"; + token.key_prefix = "--"; + token.label = "Depth order"; + token.help = "An integer value defines the number of initial independent MGSKmeans runs (2^depth_order). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stop_mgskmeans_percentage"; + token.key_prefix = "--"; + token.label = "Image assignment percentage to stop MGSKmeans [%]"; + token.help = "A floating number denotes particle assignment change percentage that serves as the converge criteria of minimum group size K-means. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10.0"; + token.restore = [['10.0'], ['10.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nsmear"; + token.key_prefix = "--"; + token.label = "Number of smears for sorting"; + token.help = "Fill it with 1 if user does not want to use all smears. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "orientation_groups"; + token.key_prefix = "--"; + token.label = "Number of orientation groups"; + token.help = "Number of orientation groups in an asymmetric unit. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "not_include_unaccounted"; + token.key_prefix = "--"; + token.label = "Do unaccounted reconstruction"; + token.help = "Do not reconstruct unaccounted elements in each generation. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "notapplybckgnoise"; + token.key_prefix = "--"; + token.label = "Use background noise flag"; + token.help = "Flag to turn off background noise. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "random_group_elimination_threshold"; + token.key_prefix = "--"; + token.label = "Random group elimination threshold"; + token.help = "A floating value denotes the random group reproducibility standard deviation for eliminating random groups. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "combinemaps"; + sxcmd.subset_config = "single map"; + sxcmd.label = "PostRefiner (Single Map)"; + sxcmd.short_info = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "combinemaps"; + token.key_prefix = "--"; + token.label = "Post-refine single map"; + token.help = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_pattern"; + token.key_prefix = ""; + token.label = "Input volume pattern"; + token.help = "Specify path pattern of input single volumes with a wild card '*' or path to single volume file (without wild card '*'). Use the wild card to indicate the place of variable part of the file names. The path pattern must be enclosed by single quotes (') or double quotes (') (Note: sxgui.py automatically adds single quotes ('))."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of input data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "Path to user-provided mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "do_adaptive_mask"; + token.key_prefix = "--"; + token.label = "Apply adaptive mask"; + token.help = "Program creates mask adaptively with given density threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "-9999.0"; + token.restore = [['-9999.0'], ['-9999.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "do_approx"; + token.key_prefix = "--"; + token.label = "Approximate values"; + token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "mtf"; + token.key_prefix = "--"; + token.label = "MTF file"; + token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mtf"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_enhance"; + token.key_prefix = "--"; + token.label = "B-factor enhancement"; + token.help = "Non-zero positive value: program use provided B-factor [A^2] to enhance the map; -1.0: B-factor is not applied."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [A]"; + token.help = "A value larger than 0.5: low-pass filter to the resolution in Angstrom; -1.0: no low-pass filter."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "output"; + token.key_prefix = "--"; + token.label = "Output file name"; + token.help = "File name of output final post-refined structure. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol_combined.hdf"; + token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "do_final"; + sxcmd.subset_config = ""; + sxcmd.label = "Final 3D Reconstruction Only"; + sxcmd.short_info = "Compute a final 3D reconstruction using either select or best resolution iteration of meridien."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "do_final"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Output Directory"; + token.help = "This directory must exist. In this mode information is read from files in this directory and the results will be written there."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_relion_3dclassifi"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Relion 3D Classfication"; + sxcmd.short_info = "A wrapper to call the relion 3D classification from the SPHIRE gui."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "post_refine_folder"; + token.key_prefix = ""; + token.label = "Post Refine Folder"; + token.help = "Input folder is the directory where the results of the post refiner are present and python routine automatically locates all the required files used for relion 3d classification. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output folder"; + token.help = "Output folder is the directory where all the results of the relion 3d classification are saved. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reference_map"; + token.key_prefix = ""; + token.label = "Reference map"; + token.help = "Reference map to be used. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reference_mask"; + token.key_prefix = "--"; + token.label = "Reference mask (optional)"; + token.help = "In case reference mask is provided by user . "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ini_high"; + token.key_prefix = "--"; + token.label = "initial low-pass filter (A)"; + token.help = "initial low pass filter in angstroms. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "60"; + token.restore = [['60'], ['60']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "symmetry"; + token.help = "symmetry use for classification. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "C1"; + token.restore = [['C1'], ['C1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "do_ctf"; + token.key_prefix = "--"; + token.label = "Do CTF-correction"; + token.help = "Whether to apply CTF correction or not. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ctf_corr_ref"; + token.key_prefix = "--"; + token.label = "Has reference been CTF-corrected"; + token.help = "Whether reference was CTF correction or not. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ctf_ignore_peak"; + token.key_prefix = "--"; + token.label = "Ignore CTFs until first peak"; + token.help = "Whether or not the first peak should be ignored or not ."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_of_class"; + token.key_prefix = "--"; + token.label = "Number of classes"; + token.help = "Number of classes to have. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "tau_val"; + token.key_prefix = "--"; + token.label = "Regularisation parameter T"; + token.help = "Regularized parameter adjusted. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_of_iter"; + token.key_prefix = "--"; + token.label = "Number of iterations"; + token.help = "Number of iterations to be performed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "25"; + token.restore = [['25'], ['25']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "diam_mas"; + token.key_prefix = "--"; + token.label = "Mask diameter (A)"; + token.help = "The diameter of the mask which use. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "200"; + token.restore = [['200'], ['200']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "zeros_mas"; + token.key_prefix = "--"; + token.label = "Mask on individual particles with zeros"; + token.help = "in case padding with zeros is required. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "limit_resol_estep"; + token.key_prefix = "--"; + token.label = "Limit resolution E-step to (A)"; + token.help = "to limit the resolution for fitting "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "heal_pix_order"; + token.key_prefix = "--"; + token.label = "Angular sampling interval in degrees"; + token.help = "output value can be from 8 to 0 depends on selection of values from 0.1 to 30 degrees "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "7.5 "; + token.restore = [['7.5 ', ' 0.1 ', ' 0.2 ', ' 0.5 ', ' 0.9 ', ' 1.8 ', ' 3.7 ', ' 15 ', ' 30'], + ['7.5 ', ' 0.1 ', ' 0.2 ', ' 0.5 ', ' 0.9 ', ' 1.8 ', ' 3.7 ', ' 15 ', ' 30']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "off_range"; + token.key_prefix = "--"; + token.label = "Offset search range (pix)"; + token.help = "Probabilities will be calculated only for translations in a circle with this radius in pixels. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "off_step"; + token.key_prefix = "--"; + token.label = "Offset search step (pix)"; + token.help = "Translations will be sampled with this step size in pixels. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "coarse_sampling"; + token.key_prefix = "--"; + token.label = "Allow coarser sampling"; + token.help = "flag only , if allow coarser sampling is set to Yes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_of_pool_part"; + token.key_prefix = "--"; + token.label = "Number of pooled particles"; + token.help = "The nr_pooled_particles parameter controls how many particles are read together for each thread. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_gpu"; + token.key_prefix = "--"; + token.label = "Use GPU acceleration"; + token.help = "Whether to use gpu for computation or not. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "which_gpu"; + token.key_prefix = "--"; + token.label = "Which GPU to use"; + token.help = "the index value of the GPU to use. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_gpu', 'True', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_gpu', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "submission_template"; + token.key_prefix = "--"; + token.label = "Submission template"; + token.help = "Submission template for mpi command "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "submission_temp"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = "--"; + token.label = "Submission command"; + token.help = "Submission commmand for cluster "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sbatch "; + token.restore = [['sbatch ', ' qsub ', ' bash'], ['sbatch ', ' qsub ', ' bash']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_mpirun_executable"; + token.key_prefix = "--"; + token.label = "relion mpirun executable"; + token.help = "Since there can be more than one mpirun environment installed on a workstation or on a cluster. It can be sometimes necessary to provide the relion specific mpirun executable. Just type which mpirun -a in a terminal and choose the one which relion requies. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "mpirun"; + token.restore = [['mpirun'], ['mpirun']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_3dclassification_executable"; + token.key_prefix = "--"; + token.label = "relion 3dclassification executable"; + token.help = "Similar to the issue of relion mpirun executable, it can be sometime necessary to provide the specific relion ctf refine executable also for that just type which relion_ctf_refine_mpi and copy the path here. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "relion_refine_mpi"; + token.restore = [['relion_refine_mpi'], ['relion_refine_mpi']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_procs"; + token.key_prefix = "--"; + token.label = "MPI Procs"; + token.help = "The number of MPI processors used for Relion multiprocessing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "no_of_threads"; + token.key_prefix = "--"; + token.label = "number of threads"; + token.help = "The number of threads use during the ctf refinement. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "abs_greyscale_map"; + token.key_prefix = "--"; + token.label = "Ref map is on absolute greyscale"; + token.help = "Whether the reference map is on absolute greyscale level or not. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_fast_sets"; + token.key_prefix = "--"; + token.label = "Use fast subsets for large datasets"; + token.help = "if selected the first 5 iterations will be done with random subsets of only K*1500 particles. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_img_align"; + token.key_prefix = "--"; + token.label = "Skip image alignment"; + token.help = "Whether to skip image alignment or not . "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ang_search"; + token.key_prefix = "--"; + token.label = "Perform local angular searches"; + token.help = "Whether to perform angular search or not. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ang_search_range"; + token.key_prefix = "--"; + token.label = "Local angular search range"; + token.help = "in case if is set to Yes, value is multiplied by 0.33333. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['ang_search', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('ang_search', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "ang_search_relax_sym"; + token.key_prefix = "--"; + token.label = "Relax Symmetry"; + token.help = "to relax symmetry . "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['ang_search', 'True', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('ang_search', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "para_io"; + token.key_prefix = "--"; + token.label = "Use parallel disc I/O"; + token.help = "if use parallel disc I/O is set to No. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_pad"; + token.key_prefix = "--"; + token.label = "Skip padding"; + token.help = "depends on the answer for skip padding, if set to No , then pad is 2 , if set to yes then pad is 1. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_grid"; + token.key_prefix = "--"; + token.label = "Skip gridding"; + token.help = "Whether to skip the grid or not. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pre_read_img"; + token.key_prefix = "--"; + token.label = "Pre-read all particles into RAM"; + token.help = "reading all particles images in memory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "scratch_dir"; + token.key_prefix = "--"; + token.label = "Copy particles to search directory"; + token.help = "if --preread_images is set to No and if a directory link is provided in Copy particles to scratch directory "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "combine_iter_disc"; + token.key_prefix = "--"; + token.label = "Combine iterations through disc"; + token.help = "Whether to combine iterations or not. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mrc_reloc_folder"; + token.key_prefix = "--"; + token.label = "mrc relocation folder"; + token.help = "In case if the mrcs images were moved from original location where they were generated to a new location. Then the user has to provide a path directory link to the new location . "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_recons3d_n"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Reconstruction"; + sxcmd.short_info = "3D Reconstruction using nearest-neighbor interpolation."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "prj_stack"; + token.key_prefix = ""; + token.label = "Input stack"; + token.help = "Stack of projections "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_volume"; + token.key_prefix = ""; + token.label = "Output volume"; + token.help = "Output reconstructed volume file "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Symmetry"; + token.help = "Symmetry. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "CTF"; + token.key_prefix = "--"; + token.label = "Apply CTF"; + token.help = "Apply CTF correction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Selection list"; + token.help = "File with list of images to be used in the first column. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbosity"; + token.help = "Enter 0 for no verbosity, 1 for verbose output. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "begin"; + token.key_prefix = ""; + token.label = "First image"; + token.help = "First image for reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "end"; + token.key_prefix = ""; + token.label = "Last image"; + token.help = "Last image for reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = ""; + token.label = "Image step"; + token.help = "Increment used for image list. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "snr"; + token.key_prefix = "--"; + token.label = "SNR"; + token.help = "Signal-to-Noise Ratio. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "group"; + token.key_prefix = "--"; + token.label = "Group number"; + token.help = "Perform reconstruction using images for a given group number (group is attribute in the header). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "npad"; + token.key_prefix = "--"; + token.label = "Padding"; + token.help = "Number of times padding "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xysize"; + token.key_prefix = "--"; + token.label = "X,Y-dimension"; + token.help = "Expected size in xy-plane. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "zsize"; + token.key_prefix = "--"; + token.label = "Z-dimension"; + token.help = "Expected size in z. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "smearstep"; + token.key_prefix = "--"; + token.label = "Smear step"; + token.help = "Rotational smear step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "interpolation_method"; + token.key_prefix = "--"; + token.label = "Interpolation method"; + token.help = "Interpolation methods: nearest neighbor (4nn), or trilinear interpolation (tril). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4nn"; + token.restore = [['4nn'], ['4nn']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "niter"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "NNumber of iterations for iterative reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10"; + token.restore = [['10'], ['10']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "upweighted"; + token.key_prefix = "--"; + token.label = "Upweight"; + token.help = "Apply background noise. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "compensate"; + token.key_prefix = "--"; + token.label = "Compensate"; + token.help = "Compensate in reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk_id"; + token.key_prefix = "--"; + token.label = "Chunk ID"; + token.help = "Reconstruct both odd and even groups of particles. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_window_size"; + token.key_prefix = "--"; + token.label = "Target window size"; + token.help = "Size of the targeted reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_sort3d"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_signalsubtract"; + sxcmd.subname = "avgfilt"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Average and Filter"; + sxcmd.short_info = "Average and low-pass filter a map for segmentation."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "avol1"; + token.key_prefix = "--"; + token.label = "Map #1 to average"; + token.help = "First map to average. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) + token = SXcmd_token(); + token.key_base = "avol2"; + token.key_prefix = "--"; + token.label = "Map #2 to average"; + token.help = "Second map to average. If not provided, first map will be used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "filtrad"; + token.key_prefix = "--"; + token.label = "Filter radius"; + token.help = "Low-pass filter radius. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'avgfilt', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'avgfilt', 'False']) + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size"; + token.help = "Pixel size in Angstroms. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_signalsubtract"; + sxcmd.subname = "sp_mask"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Generate and Apply Mask"; + sxcmd.short_info = "Make a soft mask of the region to be excluded."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "map2mask"; + token.key_prefix = "--"; + token.label = "Map to mask"; + token.help = "Map from which a mask will be generated. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) + token = SXcmd_token(); + token.key_base = "fullmap"; + token.key_prefix = "--"; + token.label = "Full map"; + token.help = "Map which will be multiplied by the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mapthresh"; + token.key_prefix = "--"; + token.label = "Map threshold"; + token.help = "Full map will be initially binarized at this threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'sp_mask', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'sp_mask', 'False']) + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_signalsubtract"; + sxcmd.subname = "projsubtract"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Project and Subtract"; + sxcmd.short_info = "Compute re-projections of map to be subtracted, and subtract them from the original images."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "origparts"; + token.key_prefix = "--"; + token.label = "Particle stack"; + token.help = "Original particle stack before signal subtraction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "map2subtract"; + token.key_prefix = "--"; + token.label = "Map to subtract"; + token.help = "Map whose projections will be subtracted from the original images. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "projparams"; + token.key_prefix = "--"; + token.label = "Projection parameters"; + token.help = "Angles and shifts, from Meridien. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nmontage"; + token.key_prefix = "--"; + token.label = "Number of examples"; + token.help = "This number of original, projections, and subtracted images will be written to disk. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "inmem"; + token.key_prefix = "--"; + token.label = "In memory?"; + token.help = "Flag to store projections in memory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "saveprojs"; + token.key_prefix = "--"; + token.label = "Save projections?"; + token.help = "Flag to save intermediate projections. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "stats"; + token.key_prefix = "--"; + token.label = "Save stats?"; + token.help = "Flag to save normalization statistics. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Skip normalization?"; + token.help = "Flag to skip normalization. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'projsubtract', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'projsubtract', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "stack"; + sxcmd.subset_config = ""; + sxcmd.label = "Compute 3D Reconstruction"; + sxcmd.short_info = "Compute a 3D reconstruction using refinement iteration used for signal-subtraction."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Particle stack to use for reconstruction (i.e., after signal-subtraction)."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Meridien Directory"; + token.help = "This directory must exist. In this mode, information is read from files in this directory. GUI will ask if you really want to continue; answer Yes."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "do_final"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "Specify the iteration which to perform final reconstruction. By setting to 0, program searches for the iteration which had best resolution, then performs correponding final reconstruction. Value must be zero or positive. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voldir"; + token.key_prefix = "--"; + token.label = "Output Reconstruction Directory"; + token.help = "Directory in which the output reconstructions will be written."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_signalsubtract"; + sxcmd.subname = "centershift"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Center Map"; + sxcmd.short_info = "Center map of remaining density."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "cvol1"; + token.key_prefix = "--"; + token.label = "Center map #1"; + token.help = "First map to average and center. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) + token = SXcmd_token(); + token.key_base = "cvol2"; + token.key_prefix = "--"; + token.label = "Center map #2"; + token.help = "Second map to average and center. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) + token = SXcmd_token(); + token.key_base = "shiftparams"; + token.key_prefix = "--"; + token.label = "Shift parameters"; + token.help = "Meridien parameters to combine with centering parameters. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) + token = SXcmd_token(); + token.key_base = "diffimgs"; + token.key_prefix = "--"; + token.label = "Subtracted images"; + token.help = "Images from signal subtraction to reconstruct. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volradius"; + token.key_prefix = "--"; + token.label = "Structure radius"; + token.help = "Radius to use for centering reconstruction. If the structure is not globular, try the shortest dimension. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['subtraction_mode', 'centershift', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('subtraction_mode', []).append([token.key_base, 'centershift', 'False']) + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size"; + token.help = "Pixel size in Angstroms. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_meridien"; + sxcmd.subname = ""; + sxcmd.mode = "local_refinement"; + sxcmd.subset_config = "stack"; + sxcmd.label = "Local Refinement from Stack"; + sxcmd.short_info = "Perform local refinement in which the restricted search begins from the user-provided orientation parameters stored in image headers. Note delta has to be less than or equal to 3.75[A]."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "local_refinement"; + token.key_prefix = "--"; + token.label = "Perform local refinement"; + token.help = "Perform local refinement starting from user-provided orientation parameters stored in the header of input image stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "The stack must have 3D orientation parameters (xform.projection) stored in image headers. They can be imported using sp_header.py."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "inires"; + token.key_prefix = "--"; + token.label = "Starting resolution [A]"; + token.help = "Resolution of the initial volume. For local refinement, the program automatically calculates the initial resolution using provided orientation parameters."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [[-1.0], [-1.0]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Initial angular sampling step [Degrees]"; + token.help = "Initial angular sampling step. For local refinement, the value has to be less than or equal to 3.75."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask3D"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "A mask applied to half-map during iterations of the program. If not given, a hard sphere of radius boxsize/2-1 will be used. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Point-group symmetry of the refined structure. Supported point groups symmetries are: cn and dn, where n is multiplicity, oct, tet, and icos. Ignored in final reconstruction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xr"; + token.key_prefix = "--"; + token.label = "Search range [Pixels]"; + token.help = "Range for translation search in both directions. Search is +/-xr. It can be fractional. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5.0"; + token.restore = [['5.0'], ['5.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ts"; + token.key_prefix = "--"; + token.label = "Search step size [Pixels]"; + token.help = "Step size of translation search in both directions. Search is within a circle of radius xr on a grid with steps ts. It can be fractional. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "User provided information about memory per node in GB (NOT per CPU). By default, it uses 2GB * (number of CPUs per node). Used in all modes. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "an"; + token.key_prefix = "--"; + token.label = "Angular neighborhood"; + token.help = "Angular neighborhood for local search. Used only in Local Refinement mode. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shake"; + token.key_prefix = "--"; + token.label = "Shake"; + token.help = "Shake randomizes grid searches by a factor of (shake x grid step). Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "small_memory"; + token.key_prefix = "--"; + token.label = "Keep data in memory"; + token.help = "Indicate if data should be kept in memory or not. By default, data will be kept in memory. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ccfpercentage"; + token.key_prefix = "--"; + token.label = "Correlation peaks to be included [%]"; + token.help = "Percentage of correlation peaks to be included. 0.0 corresponds to hard matching. Ignored in final reconstruction. This value will be adjusted during helical refinement. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = "99.9"; + token.restore = [['99.9'], ['10']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nonorm"; + token.key_prefix = "--"; + token.label = "Apply image norm correction"; + token.help = "Indicate if image norm correction should be applied or not. By default, apply image norm correction. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "function"; + token.key_prefix = "--"; + token.label = "Reference preparation function"; + token.help = "Specify name of function that the program should use to prepare the reference structure after each iteration. Ignored in final reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "do_volume_mask"; + token.restore = [['do_volume_mask'], ['do_volume_mask']]; + token.type = "user_func"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_subtract"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_locres"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Local Resolution"; + sxcmd.short_info = "Compute local resolution of a map."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "First half-map"; + token.help = "A sub-map computed from about half of input projection data. In case of quasi-independent half-refinements, it has to one of the two generated structures. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Second half-map"; + token.help = "A sub-map computed from about half of input projection data. In case of quasi-independent half-refinements, it has to one of the two generated structures. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maskfile"; + token.key_prefix = ""; + token.label = "3D mask"; + token.help = "Defines the region for which local resolution will be computed. It is advisable to eliminate irrelevant regions surrounding the structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Each voxel contains the associated resolution. It is expressed in absolute frequency units. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_continue"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix for output files. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "localres"; + token.restore = [['localres'], ['localres']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Mask radius [Pixels]"; + token.help = "In case no mask is provided, a hard sphere of this radius will be used. By default, radius = box_size/2 - (--wn). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['maskfile', 'none', 'False']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "wn"; + token.key_prefix = "--"; + token.label = "Window size [Pixels]"; + token.help = "Size of window within which local real-space CCC (equivalent to FSC) is computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "7"; + token.restore = [['7'], ['7']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Fourier shell step size [Pixels]"; + token.help = "Values larger than 1.0 increase the speed and stability of the local resolution map, but decrease its reciprocal space resolvability. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cutoff"; + token.key_prefix = "--"; + token.label = "Local resolution criterion"; + token.help = "Specify the resolution cut-off of the local resolution map. The map will contain, for each voxel, the value of spatical frequency at which local resolution at this voxel dropped below the specified cut-off level. Low values (say 0.14) result in a noisy and tus difficult to interpret local resolution map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.143"; + token.restore = [['0.143'], ['0.143']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fsc"; + token.key_prefix = "--"; + token.label = "FSC output file"; + token.help = "Contains the overall FSC curve computed by rotational averaging of local resolution values. It is truncated to --res_overall. By default, the program does not save the FSC curve. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "no curve"; + token.restore = [['no curve'], ['no curve']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "out_ang_res"; + token.key_prefix = "--"; + token.label = "Save Angstrom local resolution"; + token.help = "Additionally creates a local resolution file in Angstroms. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size of half-maps [A]"; + token.help = "Effective only with --out_ang_res options. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['out_ang_res', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('out_ang_res', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "res_overall"; + token.key_prefix = "--"; + token.label = "Overall resolution [1/Pixel]"; + token.help = "Specify overall (or global) resolution in absolute frequency (>=0.0 and <=0.5) for calibration of the average local resolution. Use the absolute frequency corresponding to the standard FSC resolution estimation. See Description section in the wiki page for details. By default, the program will not calibrate the average local resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "abs_freq"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_filterlocal"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Local Filter"; + sxcmd.short_info = "Locally filter maps according to the local resolution determined by sp_locres."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input volume"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "locres_volume"; + token.key_prefix = ""; + token.label = "Local resolution file"; + token.help = "Path to volume file containing the local resolution estimate produced by sp_locres. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maskfile"; + token.key_prefix = ""; + token.label = "3D mask"; + token.help = "Defines the region where the local filtering should be applied. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputfile"; + token.key_prefix = ""; + token.label = "Output volume"; + token.help = "Path to output volume file contained locally-filtered 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Mask radius [Pixels]"; + token.help = "In case no mask is provided, a hard sphere will be used. Use radius of the particle. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "falloff"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "The program uses a tangent low-pass filter. Specify with absolute frequency. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sxresolution"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compute mFSC"; + sxcmd.short_info = "Compute overall and local resolution measures using a pair of half-maps."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "firstvolume"; + token.key_prefix = ""; + token.label = "Volume #1"; + token.help = "First unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "secondvolume"; + token.key_prefix = ""; + token.label = "Volume #2"; + token.help = "Second unfiltered half-map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maskfile"; + token.key_prefix = ""; + token.label = "3D mask"; + token.help = "Defines the region within which FSCM will be computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputdir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where output files will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Mask radius"; + token.help = "If there is no maskfile, sphere with r=radius will be used. By default, the radius is nx/2-wn. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['maskfile', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('maskfile', []).append([token.key_base, 'None', 'False']) + token = SXcmd_token(); + token.key_base = "wn"; + token.key_prefix = "--"; + token.label = "Window size"; + token.help = "Size of window within which local real-space FSC is computed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "15"; + token.restore = [['15'], ['15']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "local_fsc"; + token.key_prefix = "--"; + token.label = "Compute local resolution"; + token.help = "Set to 1 to compute local resolution volume. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0', '1'], ['0', '1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sigmag"; + token.key_prefix = "--"; + token.label = "Sigma of Gaussian window"; + token.help = "Sigma of the Fourier space Gaussian window in pixels. Local resolution values are computed within small windowed areas (size wn^15). Due to small sample size the values are inaccurate and outcome tends to be noisy. It is thus suggested to use broader Gaussian window when local resolution is computed, say sigmag=3.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Shell step"; + token.help = "Shell step in Fourier size in pixels (integer). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "lfi"; + token.key_prefix = "--"; + token.label = "Inner radius"; + token.help = "First Fourier index from which to begin calculation (in Fourier pixels) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hfi"; + token.key_prefix = "--"; + token.label = "Outer radius"; + token.help = "Last Fourier index to end calculation (in Fourier pixels). Default radius is nx2-2. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "significance"; + token.key_prefix = "--"; + token.label = "Significance level"; + token.help = "Significance level for the upper confidence interval "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.99"; + token.restore = [['0.99'], ['0.99']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndf_reduce"; + token.key_prefix = "--"; + token.label = "Number of asymmetric units"; + token.help = "Reduction of number of degrees of freedom due to point group symmetry, for example for D3 set to 6. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cutoff"; + token.key_prefix = "--"; + token.label = "FSC criterion"; + token.help = "Resolution cut-off for FSCM confidence interval. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.143"; + token.restore = [['0.143'], ['0.143']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nthreads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "Number of threads (mainly for 3D FFT). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4"; + token.restore = [['4'], ['4']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_localres"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_unblur"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Unblur cisTEM"; + sxcmd.short_info = "Align frames of micrograph movies with Unblur."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "unblur_path"; + token.key_prefix = ""; + token.label = "Unblur executable path"; + token.help = "Specify the file path of Unblur executable. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input movie path pattern"; + token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_file"; + token.key_prefix = "--"; + token.label = "Movie selection file"; + token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrographs. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "bin_factor"; + token.key_prefix = "--"; + token.label = "Bin factor"; + token.help = "Output bin factor. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "exposure_per_frame"; + token.key_prefix = "--"; + token.label = "Per frame exposure [e/A^2]"; + token.help = "The electron dose per frame in e/A^2. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "pre_exposure"; + token.key_prefix = "--"; + token.label = "Pre-exposure [e/A^2]"; + token.help = "The electron does in e/A^2 used for exposure prior to imaging. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "additional_dose_unadjusted"; + token.key_prefix = "--"; + token.label = "Create unadjusted sums in addition"; + token.help = "Run unblur twice to also create dose unadjusted sums. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_adjustment', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_adjustment', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "gain_file"; + token.key_prefix = "--"; + token.label = "Gain file"; + token.help = "Gain file in case of gain uncorrected movies. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_dose_adjustment"; + token.key_prefix = "--"; + token.label = "Apply dose filter"; + token.help = "Indicate if dose filter should be applied or not. By default, apply dose filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "min_shift_initial"; + token.key_prefix = "--"; + token.label = "Minimum shift for initial search [A]"; + token.help = "Minimum shift for initial search [A] "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outer_radius"; + token.key_prefix = "--"; + token.label = "Outer radius shift limit [A]"; + token.help = "Outer radius shift limit "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "20.0"; + token.restore = [['20.0'], ['20.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "b_factor"; + token.key_prefix = "--"; + token.label = "Apply B-factor to images [A^2]"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1500.0"; + token.restore = [['1500.0'], ['1500.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "half_width_vert"; + token.key_prefix = "--"; + token.label = "Vertical Fourier central mask size"; + token.help = "The half-width of central vertical line of Fourier mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "half_width_hor"; + token.key_prefix = "--"; + token.label = "Horizontal Fourier central mask size"; + token.help = "The half-width of central horizontal line of Fourier mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "termination"; + token.key_prefix = "--"; + token.label = "Termination shift threshold"; + token.help = "Termination shift threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "max_iterations"; + token.key_prefix = "--"; + token.label = "Maximum iterations"; + token.help = "Maximum iterations. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "20"; + token.restore = [['20'], ['20']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dont_restore_noise_power"; + token.key_prefix = "--"; + token.label = "Restore noise power"; + token.help = "Indicate if noise power should be restored after dose adjustment or not. By default, restore noise power. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_frame"; + token.key_prefix = "--"; + token.label = "First frame"; + token.help = "First frame to use for sum. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "last_frame"; + token.key_prefix = "--"; + token.label = "Last frame"; + token.help = "Last frame to use for sum. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "distortion_angle"; + token.key_prefix = "--"; + token.label = "Distortion Angle [deg]"; + token.help = "Distortion Angle in degrees. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "major_scale"; + token.key_prefix = "--"; + token.label = "Major scale"; + token.help = "Major scale. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "minor_scale"; + token.key_prefix = "--"; + token.label = "Minor scale"; + token.help = "Minor scale. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_gui_unblur"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Drift Assessment"; + sxcmd.short_info = "Assess micrographs based on drift estimation produced by Unblur."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_pipe"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "inputfile"; + token.key_prefix = ""; + token.label = "Shift files"; + token.help = "A wild card (*) can be used to process multiple shift files. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_drift_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_shift_list_file"; + token.key_prefix = ""; + token.label = "Input shift list file"; + token.help = "Extension of input shift list file must be '.txt'. If this is not provided, all files matched with the micrograph name pattern will be processed. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_drift_params"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_unblur_old"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Unblur 1.0.2 (Pre cisTEM)"; + sxcmd.short_info = "Align frames of micrograph movies with Unblur & Summovie."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_alt"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "unblur_path"; + token.key_prefix = ""; + token.label = "Unblur executable path"; + token.help = "Specify the file path of Unblur executable. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input movie path pattern"; + token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "summovie_path"; + token.key_prefix = "--"; + token.label = "Summovie executable path"; + token.help = "Specify the file path of Summovie executable. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Movie selection file"; + token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Unblur and Summovie executables.) "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nr_frames"; + token.key_prefix = "--"; + token.label = "Number of movie frames"; + token.help = "The number of movie frames in each input micrograph. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. Will be ignored when --skip_dose_filter option is used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "exposure_per_frame"; + token.key_prefix = "--"; + token.label = "Per frame exposure [e/A^2]"; + token.help = "The electron dose per frame in e/A^2. Will be ignored when --skip_dose_filter option is used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "pre_exposure"; + token.key_prefix = "--"; + token.label = "Pre-exposure [e/A^2]"; + token.help = "The electron does in e/A^2 used for exposure prior to imaging. Will be ignored when --skip_dose_filter option is used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_dose_filter', 'True', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nr_threads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "The number of threads Unblur can use. The higher the faster, but it requires larger memory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "save_frames"; + token.key_prefix = "--"; + token.label = "Save aligned movie frames"; + token.help = "Save aligned movie frames. This option slows down the process. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_dose_filter"; + token.key_prefix = "--"; + token.label = "Apply dose filter"; + token.help = "Indicate if dose filter should be applied or not. With this option, --voltage, --exposure_per_frame, and --pre_exposure will be ignored. By default, apply dose filter. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "expert_mode"; + token.key_prefix = "--"; + token.label = "Use expert mode"; + token.help = "Requires --initial_shift, --shift_radius, --b_factor, --fourier_vertical, --fourier_horizontal, --shift_threshold, --iterations, --dont_restore_noise, and --verbosity options. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift_initial"; + token.key_prefix = "--"; + token.label = "Minimum shift for initial search [A]"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "shift_radius"; + token.key_prefix = "--"; + token.label = "Outer radius shift limit [A]"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "200.0"; + token.restore = [['200.0'], ['200.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "b_factor"; + token.key_prefix = "--"; + token.label = "Apply B-factor to images [A^2]"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "1500.0"; + token.restore = [['1500.0'], ['1500.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fourier_vertical"; + token.key_prefix = "--"; + token.label = "Vertical Fourier central mask size"; + token.help = "The half-width of central vertical line of Fourier mask. Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "fourier_horizontal"; + token.key_prefix = "--"; + token.label = "Horizontal Fourier central mask size"; + token.help = "The half-width of central horizontal line of Fourier mask. Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "shift_threshold"; + token.key_prefix = "--"; + token.label = "Termination shift threshold"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "iterations"; + token.key_prefix = "--"; + token.label = "Maximum iterations"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = "10"; + token.restore = [['10'], ['10']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "dont_restore_noise"; + token.key_prefix = "--"; + token.label = "Restore noise power"; + token.help = "Indicate if noise power should be restored or not. By default, restore noise power. Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Effective only when --expert_mode option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['expert_mode', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('expert_mode', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_summovie"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Micrograph Movie Summation"; + sxcmd.short_info = "Sum micrograph movies with Summovie."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "summovie_path"; + token.key_prefix = ""; + token.label = "Summovie executable path"; + token.help = "Specify the file path of Summovie executable. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input movie path pattern"; + token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_shift_pattern"; + token.key_prefix = ""; + token.label = "Input drift shift path pattern"; + token.help = "Specify path pattern of input drift shift parameters files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and shift file. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_drift_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Movie selection file"; + token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nr_frames"; + token.key_prefix = "--"; + token.label = "Number of movie frames"; + token.help = "The number of movie frames in each input micrograph. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first"; + token.key_prefix = "--"; + token.label = "First movie frame"; + token.help = "First movie frame for summing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "last"; + token.key_prefix = "--"; + token.label = "Last movie frame"; + token.help = "Last movie frame for summing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nr_threads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "The number of threads Summovie can use. The higher the faster, but it requires larger memory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apply_dose_filter"; + token.key_prefix = "--"; + token.label = "Apply dose filter"; + token.help = "Requires --voltage, --exposure_per_frame, and --pre_exposure options. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "exposure_per_frame"; + token.key_prefix = "--"; + token.label = "Per frame exposure [e/A^2]"; + token.help = "The electron dose per frame in e/A^2. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "pre_exposure"; + token.key_prefix = "--"; + token.label = "Pre-exposure [e/A^2]"; + token.help = "The electron does in e/A^2 used for exposure prior to imaging. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "dont_restore_noise"; + token.key_prefix = "--"; + token.label = "Restore noise power"; + token.help = "Indicate if noise power should be restored or not. By default, restore noise power. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "organize_micrographs"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Organize Micrographs/Movies"; + sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "source_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Source micrograph/movies path pattern"; + token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Micrograph/Movie selection file"; + token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "select_mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "destination_directory"; + token.key_prefix = ""; + token.label = "Destination directory"; + token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reverse"; + token.key_prefix = "--"; + token.label = "Reverse operation"; + token.help = "Move back micrographs/movies from the destination directory to the source directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "transphire"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "TranSPHIRE GUI"; + sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_movie"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_batch"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Batch Pipeline Execution"; + sxcmd.short_info = "Run jobs that wait with the execution on each other."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "submission_command"; + token.key_prefix = ""; + token.label = "Submission command"; + token.help = "Submission command, e.g., qsub, qsub -V, sbatch, bash "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_run_dir"; + token.key_prefix = ""; + token.label = "Pipeline directory"; + token.help = "Directory containin the pipeline submission files "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "hold_flag"; + token.key_prefix = "--"; + token.label = "Hold flag"; + token.help = "Hold flag for the submission command, e.g. -hold_jid=, --wait=, --dependency=afterany:; Default is None and should be used in combination with a local execution with bash "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first_hold_number"; + token.key_prefix = "--"; + token.label = "First hold number"; + token.help = "Wait number for the first job that is submitted. By default, the first job will not wait for others "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2display"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Display Data"; + sxcmd.short_info = "Displays images, volumes, or 1D plots."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "input_data_list"; + token.key_prefix = ""; + token.label = "Input files"; + token.help = "List of input images, volumes, plots. Wild cards (e.g *) can be used to select a list of files. Not recommended when the list is large. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "displayable_list"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "singleimage"; + token.key_prefix = "--"; + token.label = "Single image view"; + token.help = "Display a stack one image at a time. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fullrange"; + token.key_prefix = "--"; + token.label = "Use full range of pixel values"; + token.help = "Instead of default auto-contrast, use full range of pixel values for the display of particles stacks and 2D images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbose"; + token.help = "Accepted values 0-9. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pdb2em"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "PDB File Conversion"; + sxcmd.short_info = "Converts an atomic model stored in a PDB file into a simulated electron density map."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_pdb"; + token.key_prefix = ""; + token.label = "Input PDB file"; + token.help = "Starting atomic coordinates. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "pdb"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_hdf"; + token.key_prefix = ""; + token.label = "Output map"; + token.help = "Specify file path for output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size of output map [A]"; + token.help = "Pixel size of the output map [A]. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box"; + token.key_prefix = "--"; + token.label = "Output box size [Voxels]"; + token.help = "Specify string of a single value (e.g. '256') to get a cubic box. Alternatively, use 'x,y,z' format to specify demensions of x,y,z-axis (e.g. '128,64,256'). If not given, the program will find the minimum box size fitting the structure. Be aware that this will most likely result in a rectangular box. Note that GUI does not support the default mode. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "het"; + token.key_prefix = "--"; + token.label = "Include hetero atoms"; + token.help = "Otherwise, the HETATM entries in the PDB file are ignored. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chains"; + token.key_prefix = "--"; + token.label = "Chain identifiers"; + token.help = "A string list of chain identifiers to include (e.g. 'ABEFG'). By default, all chains will be included. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "center"; + token.key_prefix = "--"; + token.label = "Center model at the origin"; + token.help = "Specifies whether the atomic model should be moved to the origin before generating density map. Available options are: 'c' - Use the geometrical center of atoms; 'a' - Use the center of mass (recommended); 'x,y,z' - Vector to be subtracted from all PDB coordinates. 'n' - No centering, in which case (0,0,0) in the PDB space will map to the center of the EM volume. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "a"; + token.restore = [['a'], ['a']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "O"; + token.key_prefix = "--"; + token.label = "Apply additional rotation"; + token.help = "This can be used to modify the orientation of the atomic model by using O system of coordinates. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "tr0"; + token.key_prefix = "--"; + token.label = "Rotational matrix file"; + token.help = "This file must contain the 3x4 transformation matrix to be applied to the PDB coordinates after centering. The translation vector (last column of the matrix) must be specified in Angstrom. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "rot_matrix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "set_apix_value"; + token.key_prefix = "--"; + token.label = "Set header pixel size"; + token.help = "Set pixel size in header of the ouput map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "quiet"; + token.key_prefix = "--"; + token.label = "Silent mode"; + token.help = "Does not print any information to the monitor. Verbose is the default. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_relion2sphire"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "RELION to SPHIRE Conversion"; + sxcmd.short_info = "Create several types of parameter text files and per-micrograph virtual stacks of particle images in bdb format from parameters stored in a RELION STAR file"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_star_file"; + token.key_prefix = ""; + token.label = "Input RELION STAR file"; + token.help = "Specify a STAR file generated by RELION. The file should contain parameters related to Micrographs, CTF Estimation, Particle Extraction, 3D Alignment, or/and Random Subset. Entries for Micrographs category are required. If some entries associated with CTF Estimation, Particle Extraction, 3D Alignment, or/and Random Subset are missing, then the script does not produced the related output file(s). "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_relion_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "All the results will be written in here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_project_dir"; + token.key_prefix = "--"; + token.label = "RELION project directory"; + token.help = "Path to RELION project directory associated with the RELION STAR file. By default, the program assume the current directory is the RELION project directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "star_section"; + token.key_prefix = "--"; + token.label = "Section title in STAR file"; + token.help = "The section title in the RELION star file where the data should be extracted. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "data_particles"; + token.restore = [['data_particles'], ['data_particles']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sphire"; + token.restore = [['sphire'], ['sphire']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Box size"; + token.help = "Box size for particle extraction. It also controls the saved coordinates file format. If the given value is > 0, store the eman1 format. coordinate file. The coordinates of eman1 format is particle box corner associated with this box size. The coordinates of SPHIRE format is particle center. By default, use SPHIRE format. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "do_not_create_stack"; + token.key_prefix = "--"; + token.label = "Skip virtual stack creation"; + token.help = "Create per-micrograph virtual stacks without the actual particle meta information in BDB format. By default, the program does generate the stack of particle meta information. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_sphire2relion"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "SPHIRE to RELION Conversion"; + sxcmd.short_info = "Convert SPHIRE parameters to RELION."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output directory containing the output star file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "relion_project_dir"; + token.key_prefix = "--"; + token.label = "Relion project directory"; + token.help = "Relion project directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "."; + token.restore = [['.'], ['.']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_name"; + token.key_prefix = "--"; + token.label = "Output star file name"; + token.help = "Output star file name. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sphire2relion.star"; + token.restore = [['sphire2relion.star'], ['sphire2relion.star']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_stack"; + token.key_prefix = "--"; + token.label = "Particle stack"; + token.help = "Particle stack in bdb or hdf format. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "partres_file"; + token.key_prefix = "--"; + token.label = "Partres file"; + token.help = "Partres file containing the CTF information from the data set. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_2d_file"; + token.key_prefix = "--"; + token.label = "2D params file"; + token.help = "2D alignment parameters. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], + ['params_3d_file', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "params_3d_file"; + token.key_prefix = "--"; + token.label = "3D params file"; + token.help = "3D projection parameters. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], + ['params_2d_file', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('params_2d_file', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "params_3d_index_file"; + token.key_prefix = "--"; + token.label = "3D params index file"; + token.help = "Index file for the 3d params. Used to find the associated particle stack entry in the params file. In the meridien directories, this file is either called chunk or index."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "params_3d_chunk_file_0"; + token.key_prefix = "--"; + token.label = "First 3D params chunk file"; + token.help = "First chunk file for the 3d params. Used to extract the _rlnRandomSubset information. In the meridien directories, this file is called chunk. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "params_3d_chunk_file_1"; + token.key_prefix = "--"; + token.label = "Second 3D params chunk file"; + token.help = "Second chunk file for the 3d params. Used to extract the _rlnRandomSubset information. In the meridien directories, this file is called chunk. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'none', 'True'], ['params_3d_file', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('params_3d_file', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "force"; + token.key_prefix = "--"; + token.label = "Force"; + token.help = "Overwrite existing star file. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Include particle list"; + token.help = "List of particles to include. Requires --particle_stack. Cannot be used together with --exlist. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'None', 'True'], ['exlist', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'None', 'True']); + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'None', 'False']) + token = SXcmd_token(); + token.key_base = "exlist"; + token.key_prefix = "--"; + token.label = "Exclude particle list"; + token.help = "List of particles to exclude. Requires --particle_stack. Cannot be used together with --list. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['particle_stack', 'None', 'True'], ['list', 'None', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('particle_stack', []).append([token.key_base, 'None', 'True']); + sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'None', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_compare2d"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compare 2D images"; + sxcmd.short_info = "Find best match between two sets of 2D images."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "image_stack_1"; + token.key_prefix = ""; + token.label = "Input stack #1"; + token.help = "To each imagine in this stack, all of the images in the second input stack will be compared. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "image_stack_2"; + token.key_prefix = ""; + token.label = "Input stack #2"; + token.help = "Each image from this stack will be aligned to each image from the first input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where output files will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outterradius"; + token.key_prefix = "--"; + token.label = "Outer radius"; + token.help = "Outer radius in pixels. If not specified, the maximum allowed from the image dimension and maximum shift will be used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "normalize"; + token.key_prefix = "--"; + token.label = "Normalization mode"; + token.help = "Methods for displaying the images from the two inputs stacks. If both comes from the same source, uses 'None'. Other options: 'minmax' (sets the minimum and maximum for each image to constants), 'rops' (sets 1D rotational power spectra equal to each other), and 'sigmaone' (sets the average to 0 and sigma to 1). "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None', 'minmax', 'rops', 'sigmaone'], ['None', 'minmax', 'rops', 'sigmaone']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "maxshift"; + token.key_prefix = "--"; + token.label = "Maximum shift"; + token.help = "Maximum shift allowed during alignment. Alignment will be slowed significantly as the maximum shift increases. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ringstep"; + token.key_prefix = "--"; + token.label = "Ring step"; + token.help = "Alignments will be computed at this radial increment, in pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbosity"; + token.key_prefix = "--"; + token.label = "Verbosity level"; + token.help = "Controls how much information will be written to the screen, from 0..2. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_proj_compare"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Compare Re-projections"; + sxcmd.short_info = "Compare re-projections to class averages."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Set of 2D images to be compared, i.e., class averages. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input volume"; + token.help = "Reconstruction for which re-projections will be computed. In RVIPER, this file is of the form main003/run002/rotated_volume.hdf. This volume must have the same dimensions as the input images. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outdir"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Directory where outputs will be written. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mode"; + token.key_prefix = "--"; + token.label = "Comparison method"; + token.help = "Choices are: viper, projmatch, and meridien. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "projmatch"; + token.restore = [['projmatch', 'viper', 'meridien'], ['projmatch', 'viper', 'meridien']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "classangles"; + token.key_prefix = "--"; + token.label = "VIPER - Projection parameter file"; + token.help = "Parameter file containing projection angles. Not required if the projection parameters are stored in the header of the input images, which for ISAC2 is generally not the case. In RVIPER, this file is of the form main003/run002/rotated_reduced_params.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) + token = SXcmd_token(); + token.key_base = "classselect"; + token.key_prefix = "--"; + token.label = "VIPER - Image selection file"; + token.help = "Input selection containing list of images to be included from the input stack. For instance, RVIPER, if it finds a stable solution, may exclude some images, and thus their projection angles will be excluded from the parameters file. The file containing the list of included images will have a name like main003/index_keep_image.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'viper', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'viper', 'False']) + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "ProjMatch - Sampling angle"; + token.help = "Angular-sampling for reference projections. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "7.5"; + token.restore = [['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375'], + ['7.5', '15', '3.75', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "ProjMatch - Symmetry"; + token.help = "To limit angular projections. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "partangles"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Alignment parameter file"; + token.help = "Input refinement parameter file, e.g., Refine3D/final_params_037.txt. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "params_proj_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "partselect"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Particle selection file"; + token.help = "Input substack selection file if particles removed before refinement, e.g., Substack/isac_substack_particle_id_list.txt. This file is used to map the particle number before classification to particle number in refinement. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "outliers"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Outlier angle"; + token.help = "Particles differing from average Euler angle by more than this threshold (in degrees) will be excluded from average calculation, by default keeps all. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "prjmethod"; + token.key_prefix = "--"; + token.label = "Interpolation method"; + token.help = "Valid choices are trilinear, gridding, and nn. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "trilinear"; + token.restore = [['trilinear', 'gridding', 'nn'], ['trilinear', 'gridding', 'nn']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "display"; + token.key_prefix = "--"; + token.label = "e2display"; + token.help = "Automatically pops up a window with the output montage. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "matchshift"; + token.key_prefix = "--"; + token.label = "ProjMatch - Maximum shift"; + token.help = "Maximum shift to allow during translation alignment, pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "matchrad"; + token.key_prefix = "--"; + token.label = "ProjMatch - Outer radius"; + token.help = "Outer alignment radius, defaults to automatically-determined. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "matchstep"; + token.key_prefix = "--"; + token.label = "ProjMatch - Radius step size"; + token.help = "Alignment radius step size. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'projmatch', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'projmatch', 'False']) + token = SXcmd_token(); + token.key_base = "refinerad"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Outer radius"; + token.help = "Outer alignment radius, defaults to automatically-determined. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "refineshift"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Maximum shift"; + token.help = "Maximum shift to allow during translation alignment, pixels. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "refinestep"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Radius step size"; + token.help = "Alignment radius step size. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + token = SXcmd_token(); + token.key_base = "align"; + token.key_prefix = "--"; + token.label = "MERIDIEN - Alignment method"; + token.help = "Valid choices are apsh and scf. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mode', 'meridien', 'False']]; + token.default = "apsh"; + token.restore = [['apsh', 'scf'], ['apsh', 'scf']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mode', []).append([token.key_base, 'meridien', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "moon_eliminator"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Volume Adjustment"; + sxcmd.short_info = "Eliminate moons or remove dust from the background of a 3D density map based on the expected molecular mass."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume_path"; + token.key_prefix = ""; + token.label = "Input volume path"; + token.help = "Path to input volume file containing the 3D density map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Output pixel size [A]"; + token.help = "The original pixel size of dataset. This must be the pixel size after resampling when resample_ratio != 1.0. That is, it will be the pixel size of the output map. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_density_threshold', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_density_threshold', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "use_density_threshold"; + token.key_prefix = "--"; + token.label = "Use ad-hoc density threshold"; + token.help = "Use user-provided ad-hoc density threshold, instead of computing the value from the molecular mass. Below this density value, the data is assumed not to belong to the main body of the particle density. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "moon_distance"; + token.key_prefix = "--"; + token.label = "Distance to the nearest moon [Pixels]"; + token.help = "The moons further than this distance from the density surface will be elminated. The value smaller than the default is not recommended because it is difficult to avoid the stair-like gray level change at the edge of the density surface. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.0"; + token.restore = [['3.0'], ['3.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resample_ratio"; + token.key_prefix = "--"; + token.label = "Resample ratio"; + token.help = "Specify a value larger than 0.0. By default, the program does not resample the input map (i.e. resample ratio is 1.0). Use this option maily to restore the original dimensions or pixel size of VIPER or R-VIPER model. Alternatively, specify the path to the output directory of an ISAC2 run. The program automatically extracts the resampling ratio used by the ISAC2 run. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "'1.0'"; + token.restore = [["'1.0'"], ["'1.0'"]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Output box size [Pixels]"; + token.help = "The x, y, and z dimensions of cubic area to be windowed from input 3D volume for output 3D volumes. This must be the box size after resampling when resample_ratio != 1.0. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "invert_handedness"; + token.key_prefix = "--"; + token.label = "Invert handedness"; + token.help = "Invert the handedness of the 3D map. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter resolution [A]"; + token.help = ">0.0: low-pass filter to the value in Angstrom; =-1.0: no low-pass filter. The program applies this low-pass filter before the moon elimination. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_path_2nd"; + token.key_prefix = ""; + token.label = "Second input volume path"; + token.help = "Path to second input volume file containing the 3D density map. Use this option to create a mask from the sum of two MERIDIEN half-set maps. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. By default, it is set to half of --moon_distance so that the voxels with 1.0 values in the mask are same as the hard-edged molecular-mass binary volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1.0"; + token.restore = [['-1.0'], ['-1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) 'cosine' for cosine soft-edged (used in PostRefiner) and (2) 'gauss' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "outputs_root"; + token.key_prefix = "--"; + token.label = "Root name of outputs"; + token.help = "Specify the root name of all outputs. It cannot be empty string or only white spaces. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol3d"; + token.restore = [['vol3d'], ['vol3d']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resampled_shift3d"; + token.key_prefix = "--"; + token.label = "Providing resampled 3D shifts"; + token.help = "Use this option when you are providing the resampled 3D shifts (using pixel size of outputs) when --resample_ratio!=1.0. By default, the program assums the provided shifts are not resampled. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_x"; + token.key_prefix = "--"; + token.label = "3D x-shift [Pixels]"; + token.help = "3D x-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_y"; + token.key_prefix = "--"; + token.label = "3D y-shift [Pixels]"; + token.help = "3D y-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "shift3d_z"; + token.key_prefix = "--"; + token.label = "3D z-shift [Pixels]"; + token.help = "3D z-shift value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off in absolute frequency. The program applies this low-pass filter before the moon elimination. Effective only when --fl > 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.1"; + token.restore = [['0.1'], ['0.1']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "debug"; + token.key_prefix = "--"; + token.label = "Run with debug mode"; + token.help = "Mainly for developers. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_mask"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Masking"; + sxcmd.short_info = "Mask creation tool for 2D or 3D masks."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input image"; + token.help = "Path to the 2D image or 3D Volume "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output direcory path "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "Output prefix"; + token.help = "Prefix of the produced files "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "sp_mask"; + token.restore = [['sp_mask'], ['sp_mask']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "overwrite"; + token.key_prefix = "--"; + token.label = "Overwrite outputs"; + token.help = "Overwrite the output mask in case it exists already. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A/px]"; + token.help = "Pixel size of the volume. Used for filtering and the molcular mask threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['nsigma', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. This is used to calculate the binarization threshold automatically. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', 'none', 'False'], ['use_mol_mass', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One cycle of dilation will add about 2 pixels to the mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking. If the width is 0, a binary mask is returned. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "allow_disconnected"; + token.key_prefix = "--"; + token.label = "Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fill_mask"; + token.key_prefix = "--"; + token.label = "Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nerosion"; + token.key_prefix = "--"; + token.label = "Number of erosions"; + token.help = "Number of times to erode binarized volume. One cycle of erosion will remove about 2 pixels from the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "do_old"; + token.key_prefix = "--"; + token.label = "Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "low_pass_filter_resolution"; + token.key_prefix = "--"; + token.label = "Low pass filter resolution [A]"; + token.help = "Low pass filter resolution in angstroms. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "low_pass_filter_falloff"; + token.key_prefix = "--"; + token.label = "Low pass filter falloff [1/Pixel]"; + token.help = "Low pass filter falloff in absolute frequencies. If set, the volume will be filtered prior to create a mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['low_pass_filter_resolution', 'none', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('low_pass_filter_resolution', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "use_second_mask"; + token.key_prefix = "--"; + token.label = "Use a second mask"; + token.help = "ONLY A GUI OPTION. The second mask can be used to mask the first one after creation. This is useful to create soft edged regions of the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [True]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "second_mask"; + token.key_prefix = "--"; + token.label = "Second mask path"; + token.help = "Path to the input second mask used for masking the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], + ['second_mask_shape', 'none', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "second_mask_shape"; + token.key_prefix = "--"; + token.label = "Second mask shape"; + token.help = "Shape of the second mask. Possible values: sphere, cylinder, cube. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'False']]; + token.default = "none"; + token.restore = [['none', 'sphere', 'cylinder', 'cube'], ['cylinder', 'none', 'sphere', 'cube']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "s_radius"; + token.key_prefix = "--"; + token.label = "Second - Radius of the mask"; + token.help = "Radius of the sphere or cylinder for the second mask in pixels. Radius must be less than half of the volume dimension. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['second_mask_shape', 'cube', 'True'], ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'cube', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nx"; + token.key_prefix = "--"; + token.label = "Second - X dimension of the mask"; + token.help = "X Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_ny"; + token.key_prefix = "--"; + token.label = "Second - Y dimension of the mask"; + token.help = "Y Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_nz"; + token.key_prefix = "--"; + token.label = "Second - Z dimension of the mask"; + token.help = "Z Dimensions of the second mask. The mask is clipped to the input volume size afterwards. Therefore this values can be used to generate a percentage mask for helical processing. If not provided, a squared volume with s_nx is assumed. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['second_mask_shape', 'none', 'True'], + ['use_second_mask', 'True', 'False'], ['s_nx', 'none;Main', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('second_mask_shape', []).append([token.key_base, 'none', 'True']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_nx', []).append([token.key_base, 'none;Main', 'True']) + token = SXcmd_token(); + token.key_base = "s_pixel_size"; + token.key_prefix = "--"; + token.label = "Second - Pixel size [A/px]"; + token.help = "Pixel size of the second volume. Used for the molecular mass threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_use_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_nsigma', 'none', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_mol_mass"; + token.key_prefix = "--"; + token.label = "Second - Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodalton. This is used to calculate the binarization threshold automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_use_mol_mass', 'True', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_threshold"; + token.key_prefix = "--"; + token.label = "Second - Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value is lower-equal than the default, the option will be ignored and the threshold will be set according to nsigma method above. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_nsigma', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_nsigma', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_nsigma"; + token.key_prefix = "--"; + token.label = "Second - Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is none. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['s_threshold', 'none', 'False'], ['s_use_mol_mass', 'False', 'False'], + ['use_second_mask', 'True', 'False'], ['second_mask', 'none', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('s_threshold', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('s_use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('second_mask', []).append([token.key_base, 'none', 'True']) + token = SXcmd_token(); + token.key_base = "s_ndilation"; + token.key_prefix = "--"; + token.label = "Second - Number of dilations"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge. One round of erosion will add about 2 pixels to the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_nerosion"; + token.key_prefix = "--"; + token.label = "Second - Number of erosions"; + token.help = "Number of times to erode binarized volume. One round of erosion will remove about 2 pixels from the mask "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_width"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "main"; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_edge_type"; + token.key_prefix = "--"; + token.label = "Second - Soft-edge type"; + token.help = "The type of soft-edge for the 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gaussian\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_do_old"; + token.key_prefix = "--"; + token.label = "Second - Old behaviour"; + token.help = "Restore the old masking behaviour, which is a bit less smooth. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False'], ['s_edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('s_edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "s_allow_disconnected"; + token.key_prefix = "--"; + token.label = "Second - Allow disconnected regions"; + token.help = "Allow disconnected region in the mask. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "s_fill_mask"; + token.key_prefix = "--"; + token.label = "Second - Fill mask"; + token.help = "Fills empty spaces inside a map. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "s_invert"; + token.key_prefix = "--"; + token.label = "Second - Invert masking"; + token.help = "If True, the mask will remove everything that is inside instead of leaving it. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_second_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_second_mask', []).append([token.key_base, 'True', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "changesize"; + sxcmd.subset_config = ""; + sxcmd.label = "Change Size of Image or Volume"; + sxcmd.short_info = "Change size of image or map (decimate or interpolate up). The process results in changed pixel and window sizes. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "changesize"; + token.key_prefix = "--"; + token.label = "Change size of image or map"; + token.help = "Change size of image or map (decimate or interpolate up). The process results in changed pixel and window sizes. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_stack"; + token.key_prefix = ""; + token.label = "Input image or volume"; + token.help = "Input image or volume."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data2d3d_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_stack"; + token.key_prefix = ""; + token.label = "Output resized image or volume"; + token.help = "Resized (decimated or interpolated up) image or volume."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ratio"; + token.key_prefix = "--"; + token.label = "Ratio of new to old image size"; + token.help = "If < 1, the pixel size will increase and image size decrease. if > 1, the other way round. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2proc3d"; + sxcmd.subname = ""; + sxcmd.mode = "clip"; + sxcmd.subset_config = ""; + sxcmd.label = "Window Volume"; + sxcmd.short_info = "Window (pad or clip) volume to the specific dimensions. Specify 1, 3 or 6 arguments; '<x>[,<y>,<z>[,<xc>,<yc>,<zc>]]'. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "clip"; + token.key_prefix = "--"; + token.label = "Window to specified size [Pixels]"; + token.help = "Window (pad or clip) volume to the specific dimensions. Specify 1, 3 or 6 arguments; '<x>[,<y>,<z>[,<xc>,<yc>,<zc>]]'. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume"; + token.key_prefix = ""; + token.label = "Input volume"; + token.help = "Path to input volume file."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_file"; + token.key_prefix = ""; + token.label = "Output windowed volume"; + token.help = "Path to output windowed (clipped/padded) volume file."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "angular_distribution"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Angular Distribution"; + sxcmd.short_info = "Generate a chimera .bild file for the visual representation of the resulting projection parameters."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "File containing the 3D projection parameters "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_folder"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Output folder name "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "prefix"; + token.key_prefix = "--"; + token.label = "File prefix"; + token.help = "Prefix for the output files - None uses the same name as the params file - Existing files will be overwritten "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "Symmetry - c0 creates full sphere distribution; XXX_full, e.g. c1_full, c4_full, icos_full, creates a histogram for both hemispheres. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Box size "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "256"; + token.restore = [['256'], ['256']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of the project "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "particle_radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Particle radius "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "120"; + token.restore = [['120'], ['120']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Angular sampling step [Degrees]"; + token.help = "Angular step size in degree - Low deltas combined with low symmetry might crash chimera session "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3.75"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "method"; + token.key_prefix = "--"; + token.label = "Distribution method"; + token.help = "Method used to create the reference angles (S or P or M) "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = "advanced"; + token.dependency_group = [['', '', '']]; + token.default = "S"; + token.restore = [['S', 'M', 'P'], ['M', 'P', 'S']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "dpi"; + token.key_prefix = "--"; + token.label = "Plot DPI"; + token.help = "Dpi for the legend plot "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "144"; + token.restore = [['144'], ['144']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nth_percentile"; + token.key_prefix = "--"; + token.label = "Nth percentil"; + token.help = "Use the value of the nth percentile of the radius distribution for normalization "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "99"; + token.restore = [['99'], ['99']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "old"; + token.key_prefix = "--"; + token.label = "Use old"; + token.help = "Use the old color scheme and normalization. The old style was normalizing the maximum length instead of the nth percentile and used a blue to green instead of a blue over green to yellow color scheme. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_recons3d_n"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "3D Reconstruction"; + sxcmd.short_info = "3D Reconstruction using nearest-neighbor interpolation."; + sxcmd.mpi_support = True; + sxcmd.mpi_add_flag = True; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "prj_stack"; + token.key_prefix = ""; + token.label = "Input stack"; + token.help = "Stack of projections "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_volume"; + token.key_prefix = ""; + token.label = "Output volume"; + token.help = "Output reconstructed volume file "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "sym"; + token.key_prefix = "--"; + token.label = "Symmetry"; + token.help = "Symmetry. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "CTF"; + token.key_prefix = "--"; + token.label = "Apply CTF"; + token.help = "Apply CTF correction. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Selection list"; + token.help = "File with list of images to be used in the first column. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "verbose"; + token.key_prefix = "--"; + token.label = "Verbosity"; + token.help = "Enter 0 for no verbosity, 1 for verbose output. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "begin"; + token.key_prefix = ""; + token.label = "First image"; + token.help = "First image for reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "end"; + token.key_prefix = ""; + token.label = "Last image"; + token.help = "Last image for reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = ""; + token.label = "Image step"; + token.help = "Increment used for image list. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "snr"; + token.key_prefix = "--"; + token.label = "SNR"; + token.help = "Signal-to-Noise Ratio. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "group"; + token.key_prefix = "--"; + token.label = "Group number"; + token.help = "Perform reconstruction using images for a given group number (group is attribute in the header). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "npad"; + token.key_prefix = "--"; + token.label = "Padding"; + token.help = "Number of times padding "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "xysize"; + token.key_prefix = "--"; + token.label = "X,Y-dimension"; + token.help = "Expected size in xy-plane. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "zsize"; + token.key_prefix = "--"; + token.label = "Z-dimension"; + token.help = "Expected size in z. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "smearstep"; + token.key_prefix = "--"; + token.label = "Smear step"; + token.help = "Rotational smear step. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "interpolation_method"; + token.key_prefix = "--"; + token.label = "Interpolation method"; + token.help = "Interpolation methods: nearest neighbor (4nn), or trilinear interpolation (tril). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "4nn"; + token.restore = [['4nn'], ['4nn']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "niter"; + token.key_prefix = "--"; + token.label = "Iteration number"; + token.help = "NNumber of iterations for iterative reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "10"; + token.restore = [['10'], ['10']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "upweighted"; + token.key_prefix = "--"; + token.label = "Upweight"; + token.help = "Apply background noise. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "compensate"; + token.key_prefix = "--"; + token.label = "Compensate"; + token.help = "Compensate in reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk_id"; + token.key_prefix = "--"; + token.label = "Chunk ID"; + token.help = "Reconstruct both odd and even groups of particles. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_window_size"; + token.key_prefix = "--"; + token.label = "Target window size"; + token.help = "Size of the targeted reconstruction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_cryolo_boxmanager"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "crYOLO - boxmanager"; + sxcmd.short_info = "Displays boxfiles on images. Allows creation of new training data for crYOLO."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "cryolo_bm_path"; + token.key_prefix = "--"; + token.label = "crYOLO boxmanager executable"; + token.help = "Path to crYOLO boxmanager executable "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "target_dir"; + token.key_prefix = "--"; + token.label = "Input image directory"; + token.help = "Path to input images "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_dir"; + token.key_prefix = "--"; + token.label = "Annotation directory"; + token.help = "Path to annotation data like .box or .star files "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "balance_angular_distribution"; + sxcmd.subset_config = ""; + sxcmd.label = "Balance Angular Distribution"; + sxcmd.short_info = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "balance_angular_distribution"; + token.key_prefix = "--"; + token.label = "Balance Angular Distribution"; + token.help = "Balance angular distribution of projection directions by removing excess particles, as determined by their angular histogram on a coarser grid, as specified by the angular_step option. "; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_any_txt"; + token.key_prefix = ""; + token.label = "Projection parameters"; + token.help = "Typically from MERIDIEN with a filename in the form of Refine3D/final_params_0##.txt"; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Output selection list"; + token.help = "Text file with a list of retained particle images"; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "max_occupy"; + token.key_prefix = "--"; + token.label = "Maximum orientations per reference angle"; + token.help = "Maximum number of particles per reference angle. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "angstep"; + token.key_prefix = "--"; + token.label = "Angular increment"; + token.help = "Angular step of reference angles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "15"; + token.restore = [['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375'], + ['3.75', '15', '7.5', '1.875', '0.9375', '0.46875', '0.234375']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Point-group symmetry"; + token.help = "angular step of reference angles, i.e., number of bins of angular histogram. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_process"; + sxcmd.subname = ""; + sxcmd.mode = "combinemaps"; + sxcmd.subset_config = "single map"; + sxcmd.label = "PostRefiner (Single Map)"; + sxcmd.short_info = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "combinemaps"; + token.key_prefix = "--"; + token.label = "Post-refine single map"; + token.help = "Post-refine a single map by enhancing the high frequencies (Single Map Mode). Only ad-hoc low-pass filter cutoff and B-factor can be used. This mode requires one argument; path pattern with wild card '*' to specify a list of volumes or a path to a volume (without wild card '*')."; + token.group = "main"; + token.is_required = True; + token.is_locked = True; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_volume_pattern"; + token.key_prefix = ""; + token.label = "Input volume pattern"; + token.help = "Specify path pattern of input single volumes with a wild card '*' or path to single volume file (without wild card '*'). Use the wild card to indicate the place of variable part of the file names. The path pattern must be enclosed by single quotes (') or double quotes (') (Note: sxgui.py automatically adds single quotes ('))."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_dir"; + token.key_prefix = "--"; + token.label = "Output directory"; + token.help = "Specify path to the output directory for PostRefiner process. By default, the program uses the current directory. However, GUI requires the path other than the current directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size of input data. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "3D mask file"; + token.help = "Path to user-provided mask. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "do_adaptive_mask"; + token.key_prefix = "--"; + token.label = "Apply adaptive mask"; + token.help = "Program creates mask adaptively with given density threshold. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['mask', 'none', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('mask', []).append([token.key_base, 'none', 'False']) + token = SXcmd_token(); + token.key_base = "use_mol_mass"; + token.key_prefix = "--"; + token.label = "Use molecular mass"; + token.help = "GUI OPTION ONLY - Define if one want to use the molecular mass option as a masking threshold. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['nsigma', '1.0', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool_ignore"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The estimated molecular mass of the target particle in kilodaltons. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['use_mol_mass', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "threshold"; + token.key_prefix = "--"; + token.label = "Binarization threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the input structure. If the value changed from the default, the option will be ignored and the threshold will be set according to nsigma method under the Advanced tab. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['nsigma', '1.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "-9999.0"; + token.restore = [['-9999.0'], ['-9999.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('nsigma', []).append([token.key_base, '1.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "nsigma"; + token.key_prefix = "--"; + token.label = "Density standard deviation threshold"; + token.help = "Defines the threshold used in the first step of the processing to generate a binary version of the structure. The threshold is set to <= mean + (nsigma x standard deviations). This option will not be used if the option threshold is larger than -9999.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['threshold', '-9999.0', 'False'], ['use_mol_mass', 'False', 'False'], + ['do_adaptive_mask', 'True', 'False']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('threshold', []).append([token.key_base, '-9999.0', 'False']); + sxcmd.dependency_dict.setdefault('use_mol_mass', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "ndilation"; + token.key_prefix = "--"; + token.label = "Dilation width [Pixels]"; + token.help = "The pixel width to dilate the 3D binary volume corresponding to the specified molecular mass or density threshold prior to softening the edge "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_width"; + token.key_prefix = "--"; + token.label = "Soft-edge width [Pixels]"; + token.help = "The pixel width of transition area for soft-edged masking."; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "edge_type"; + token.key_prefix = "--"; + token.label = "Soft-edge type"; + token.help = "The type of soft-edge for moon-eliminator 3D mask and a moon-eliminated soft-edged 3D mask. Available methods are (1) \'cosine\' for cosine soft-edged (used in PostRefiner) and (2) \'gauss\' for gaussian soft-edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['do_adaptive_mask', 'True', 'False']]; + token.default = "cosine"; + token.restore = [['cosine'], ['cosine']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('do_adaptive_mask', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "do_approx"; + token.key_prefix = "--"; + token.label = "Approximate values"; + token.help = "Approximate the values of the soft edge area instead of using the exact values. This will lead to a less smoothened mask, but will mirror the previous behaviour. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['edge_width', '0', 'True']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('edge_width', []).append([token.key_base, '0', 'True']) + token = SXcmd_token(); + token.key_base = "mtf"; + token.key_prefix = "--"; + token.label = "MTF file"; + token.help = "Path to file contains the MTF (modulation transfer function) of the detector used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mtf"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "B_enhance"; + token.key_prefix = "--"; + token.label = "B-factor enhancement"; + token.help = "Non-zero positive value: program use provided B-factor [A^2] to enhance the map; -1.0: B-factor is not applied."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "fl"; + token.key_prefix = "--"; + token.label = "Low-pass filter frequency [A]"; + token.help = "A value larger than 0.5: low-pass filter to the resolution in Angstrom; -1.0: no low-pass filter."; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "aa"; + token.key_prefix = "--"; + token.label = "Low-pass filter fall-off [1/Pixels]"; + token.help = "Low-pass filter fall-off. Effective only when --fl option is not -1.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['fl', '-1.0', 'True']]; + token.default = "0.01"; + token.restore = [['0.01'], ['0.01']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('fl', []).append([token.key_base, '-1.0', 'True']) + token = SXcmd_token(); + token.key_base = "output"; + token.key_prefix = "--"; + token.label = "Output file name"; + token.help = "File name of output final post-refined structure. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "vol_combined.hdf"; + token.restore = [['vol_combined.hdf'], ['vol_combined.hdf']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_summovie"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Micrograph Movie Summation"; + sxcmd.short_info = "Sum micrograph movies with Summovie."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "summovie_path"; + token.key_prefix = ""; + token.label = "Summovie executable path"; + token.help = "Specify the file path of Summovie executable. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Input movie path pattern"; + token.help = "Specify path pattern of input micrograph movies with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). bdb files cannot be selected as input micrograph movies. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_shift_pattern"; + token.key_prefix = ""; + token.label = "Input drift shift path pattern"; + token.help = "Specify path pattern of input drift shift parameters files with a wild card (*).. The path pattern must be enclosed by single quotes (') or double quotes ('). (Note: sp_gui.py automatically adds single quotes (')). The substring at the variable part must be same between the associated pair of input micrograph and shift file. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_drift_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. It cannot be an existing one. (This argument is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = "--"; + token.label = "Movie selection file"; + token.help = "Specify a name of micrograph movie selection list text file. The file extension must be '.txt'. If this is not provided, all files matched with the micrograph movie name pattern will be processed. (This option is specific to SPHIRE, and not directly used by Summovie executable.) "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nr_frames"; + token.key_prefix = "--"; + token.label = "Number of movie frames"; + token.help = "The number of movie frames in each input micrograph. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "3"; + token.restore = [['3'], ['3']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "first"; + token.key_prefix = "--"; + token.label = "First movie frame"; + token.help = "First movie frame for summing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "last"; + token.key_prefix = "--"; + token.label = "Last movie frame"; + token.help = "Last movie frame for summing. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "pixel_size"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrographs. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "nr_threads"; + token.key_prefix = "--"; + token.label = "Number of threads"; + token.help = "The number of threads Summovie can use. The higher the faster, but it requires larger memory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1"; + token.restore = [['1'], ['1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apply_dose_filter"; + token.key_prefix = "--"; + token.label = "Apply dose filter"; + token.help = "Requires --voltage, --exposure_per_frame, and --pre_exposure options. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "exposure_per_frame"; + token.key_prefix = "--"; + token.label = "Per frame exposure [e/A^2]"; + token.help = "The electron dose per frame in e/A^2. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "2.0"; + token.restore = [['2.0'], ['2.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "pre_exposure"; + token.key_prefix = "--"; + token.label = "Pre-exposure [e/A^2]"; + token.help = "The electron does in e/A^2 used for exposure prior to imaging. Effective only when --apply_dose_filter option is used. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['apply_dose_filter', 'True', 'False']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('apply_dose_filter', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "dont_restore_noise"; + token.key_prefix = "--"; + token.label = "Restore noise power"; + token.help = "Indicate if noise power should be restored or not. By default, restore noise power. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = True; + token.restore = [[True], [True]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_header"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Header Operations"; + sxcmd.short_info = "Perform operations on headers of hdf or bdb file."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "stack"; + token.key_prefix = ""; + token.label = "Input image stack"; + token.help = "Path to input image stack. The stack can be either bdb or hdf. However, the GUI supports only bdb. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params"; + token.key_prefix = "--"; + token.label = "Target parameters"; + token.help = "List of parameters names (i.e. image header entry keys) to perform operations on (e.g. 'parm1 parm2 ...'). "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "import"; + token.key_prefix = "--"; + token.label = "Import parameters"; + token.help = "Import parameters from file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "export"; + token.key_prefix = "--"; + token.label = "Export parameters"; + token.help = "Export parameters to file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delete"; + token.key_prefix = "--"; + token.label = "Delete all"; + token.help = "Delete all parameters. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "zero"; + token.key_prefix = "--"; + token.label = "Set to zero"; + token.help = "Set all parameters to zero. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "one"; + token.key_prefix = "--"; + token.label = "Set to one"; + token.help = "Set all parameters to one. This is not applicable to xform.align2d, xform.proj or xform.align3d, beccause they do not make sense. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "set"; + token.key_prefix = "--"; + token.label = "Set to constant"; + token.help = "Set parameters to a specified constant value, other than 0.0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0"; + token.restore = [['0.0'], ['0.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "consecutive"; + token.key_prefix = "--"; + token.label = "Set to consecutive"; + token.help = "Set selected parameters to consecutive integers starting from 0. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "randomize"; + token.key_prefix = "--"; + token.label = "Set to random"; + token.help = "Set all parameters to randomized value. This works only for xform.align2d, xform.proj and xform.align3d since there is little need to randomize the other parameters and it is also difficult to guess the random range beforehand. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rand_alpha"; + token.key_prefix = "--"; + token.label = "Set angles to random"; + token.help = "Set all angles to random values. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "print"; + token.key_prefix = "--"; + token.label = "Print to screen"; + token.help = "Print parameters to screen. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "backup"; + token.key_prefix = "--"; + token.label = "Backup all"; + token.help = "Backup all parameters. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "restore"; + token.key_prefix = "--"; + token.label = "Restore all"; + token.help = "Restore all parameters. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "suffix"; + token.key_prefix = "--"; + token.label = "Suffix for backup"; + token.help = "Suffix for xform name in backup. This will be added to the name of a parameter or removed during restore. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "_backup"; + token.restore = [['_backup'], ['_backup']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "e2bdb"; + sxcmd.subname = ""; + sxcmd.mode = "makevstack"; + sxcmd.subset_config = ""; + sxcmd.label = "Create Virtual Stack"; + sxcmd.short_info = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "makevstack"; + token.key_prefix = "--"; + token.label = "Output virtual image stack"; + token.help = "Make a 'virtual' bdb image stack with the specified name from one or more other stacks. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output_bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "input_bdb_stack_file"; + token.key_prefix = ""; + token.label = "Input BDB image stack"; + token.help = "Specify path to input BDB stack file. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "list"; + token.key_prefix = "--"; + token.label = "Image selection file"; + token.help = "Input selection text file containing a list of selected image IDs (or indexes of the data subset) to create a new virtual bdb image stack from an existed stack or virtual stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['exlist', 'none', 'False'], ['step', '0,1', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) + token = SXcmd_token(); + token.key_base = "exlist"; + token.key_prefix = "--"; + token.label = "Image exclusion file"; + token.help = "Input exclusion text file containing a list of excluded image IDs (or indexes of the data subset) to create a new virtual bdb image stacks from an existed stack or virtual stack. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['step', '0,1', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('step', []).append([token.key_base, '0,1', 'False']) + token = SXcmd_token(); + token.key_base = "step"; + token.key_prefix = "--"; + token.label = "Processes only subset"; + token.help = "Specify <init>,<step>[,<max>]. Process only a subset of the input data. For example, 0,2 would process only the even numbered particles. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['list', 'none', 'False'], ['exlist', 'none', 'False']]; + token.default = "0,1"; + token.restore = [['0,1'], ['0,1']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('list', []).append([token.key_base, 'none', 'False']); + sxcmd.dependency_dict.setdefault('exlist', []).append([token.key_base, 'none', 'False']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_pipe"; + sxcmd.subname = "organize_micrographs"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Organize Micrographs/Movies"; + sxcmd.short_info = "Organize micrographs/movies by moving micrographs/movies listed in a selecting file from a source directory (specified by source micrographs/movies pattern) to a destination directory."; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "source_micrograph_pattern"; + token.key_prefix = ""; + token.label = "Source micrograph/movies path pattern"; + token.help = "Specify path pattern of source micrographs/movies with a wild card (*). The path pattern must be enclosed by single quotes (\') or double quotes (\'). (Note: sp_gui.py automatically adds single quotes (\')). The substring at the variable part must be same between each associated pair of micrograph/movie names. bdb files cannot be selected as source micrographs/movies. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "selection_list"; + token.key_prefix = ""; + token.label = "Micrograph/Movie selection file"; + token.help = "Specify a path of text file containing a list of selected micrograph/movie names or paths. The file extension must be '.txt'. The directory path of each entry will be ignored if there are any. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "select_mic_both"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "destination_directory"; + token.key_prefix = ""; + token.label = "Destination directory"; + token.help = "The micrographs/movies in selecting list will be moved to this directory. It cannot be an existing one. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "reverse"; + token.key_prefix = "--"; + token.label = "Reverse operation"; + token.help = "Move back micrographs/movies from the destination directory to the source directory. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "check_consistency"; + token.key_prefix = "--"; + token.label = "Check consistency of dataset"; + token.help = "Create a text file containing the list of micrograph/movie ID entries might have inconsistency among the provided dataset. (i.e. mic_consistency_check_info.txt). "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "meridien"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Meridien)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "refinement_dir"; + token.key_prefix = ""; + token.label = "Meridien directory"; + token.help = "Path to Meridien directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_ctf_refine"; + sxcmd.subname = "manual"; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "CTF refine (Stack)"; + sxcmd.short_info = "Refine the defocus per particle"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = True + token = SXcmd_token(); + token.key_base = "path_to_input_stack"; + token.key_prefix = ""; + token.label = "Input stack path"; + token.help = "Path to input stack. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_star"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "Folder to output files etc. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume_path"; + token.key_prefix = ""; + token.label = "Path to volume"; + token.help = "Path to volume. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "params_file"; + token.key_prefix = ""; + token.label = "Params file"; + token.help = "Path to params file "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mask"; + token.key_prefix = "--"; + token.label = "Path to mask"; + token.help = "Path to mask used. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "range"; + token.key_prefix = "--"; + token.label = "Defocus search range [um]"; + token.help = "Search range +- around the current defocus value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.15"; + token.restore = [['0.15'], ['0.15']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "delta"; + token.key_prefix = "--"; + token.label = "Defocus search delta [um]"; + token.help = "Finest search delta. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "0.0025"; + token.restore = [['0.0025'], ['0.0025']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "resolution"; + token.key_prefix = "--"; + token.label = "Nominal resolution [A]"; + token.help = "Nominal resolution of the reconstruction. Low-pass Gaussian filter will be applied at this resolution. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "Pixel size in Angstroms. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['resolution', 'None', 'True']]; + token.default = "None"; + token.restore = [['None'], ['None']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('resolution', []).append([token.key_base, 'None', 'True']) + token = SXcmd_token(); + token.key_base = "number_part"; + token.key_prefix = "--"; + token.label = "Number of particles"; + token.help = "Number of particles to process. Mainly for debugging. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "chunk"; + token.key_prefix = "--"; + token.label = "Path to chunk file"; + token.help = "Path to chunk file "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "select_data2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "volume2"; + token.key_prefix = "--"; + token.label = "Path to second volume"; + token.help = "Path to second half volume. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['chunk', 'None', 'True']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('chunk', []).append([token.key_base, 'None', 'True']) + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "sp_auto"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "Auto SPHIRE"; + sxcmd.short_info = "Run SPHIRE up to 3D refinement in an automated manner"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False + token = SXcmd_token(); + token.key_base = "output_directory"; + token.key_prefix = ""; + token.label = "Output directory"; + token.help = "The results will be written here. If not given, the program will use name master_DATA_AND_TIME. For standard continuation run, local refinement from iteration, and final reconstruction only, the directory must exist and further iterations will be written to this directory. "; + token.group = "main"; + token.is_required = True; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = ""; + token.restore = [[""], [""]]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "apix"; + token.key_prefix = "--"; + token.label = "Pixel size [A]"; + token.help = "The pixel size of input micrographs. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "1.0"; + token.restore = [['1.0'], ['1.0']]; + token.type = "apix"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mol_mass"; + token.key_prefix = "--"; + token.label = "Molecular mass [kDa]"; + token.help = "The molecular mass of the protein in kilo Dalton. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "250"; + token.restore = [['250'], ['250']]; + token.type = "mass"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "radius"; + token.key_prefix = "--"; + token.label = "Particle radius [Pixels]"; + token.help = "Outer particle radius in pixels < int(boxsize/2)-1. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "80"; + token.restore = [['80'], ['80']]; + token.type = "radius"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "box_size"; + token.key_prefix = "--"; + token.label = "Particle box size [Pixels]"; + token.help = "Particle box size. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "200"; + token.restore = [['200'], ['200']]; + token.type = "box"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "symmetry"; + token.key_prefix = "--"; + token.label = "Symmetry"; + token.help = "Symmetry of the protein. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "c1"; + token.restore = [['c1'], ['c1']]; + token.type = "sym"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "voltage"; + token.key_prefix = "--"; + token.label = "Microscope voltage [kV]"; + token.help = "The acceleration voltage of microscope used for imaging. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "300.0"; + token.restore = [['300.0'], ['300.0']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "negative_stain"; + token.key_prefix = "--"; + token.label = "Is neg. stain data set"; + token.help = "Check if the data set is collected via negative stain. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['phase_plate', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('phase_plate', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "phase_plate"; + token.key_prefix = "--"; + token.label = "Is VPP data set"; + token.help = "Check if the data set is collected with a phase plate. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['negative_stain', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('negative_stain', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "fill_rviper_mask"; + token.key_prefix = "--"; + token.label = "Do not fill the mask for 3D refinement"; + token.help = "Check if you do not want to fill the mask for the first 3D refinement. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mtf"; + token.key_prefix = "--"; + token.label = "MTF file"; + token.help = "Path to the MTF file of the used detector. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mtf"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "memory_per_node"; + token.key_prefix = "--"; + token.label = "Memory per node [GB]"; + token.help = "Available memory per node. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "-1"; + token.restore = [['-1'], ['-1']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "unblur_path"; + token.key_prefix = "--"; + token.label = "Unblur executable"; + token.help = "Path to the unblur executable. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "exe"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "unblur_mic_pattern"; + token.key_prefix = "--"; + token.label = "Unblur micrograph patten"; + token.help = "Micrograph pattern containing the wildcard character *. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mic_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "unblur_exp_per_frame"; + token.key_prefix = "--"; + token.label = "Unblur exposure per frame [e/A^2]"; + token.help = "Exposure per frame for dose adjustment. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "unblur_gain_file"; + token.key_prefix = "--"; + token.label = "Unblur gain file"; + token.help = "Path to the gain file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cter_cs"; + token.key_prefix = "--"; + token.label = "CTER spherical aberration (Cs) [mm]"; + token.help = "Spherical aberration of the microscope. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; + token.default = "2.7"; + token.restore = [['2.7'], ['2.7']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_predict_path"; + token.key_prefix = "--"; + token.label = "CrYOLO predict path"; + token.help = "Path to the CrYOLO precict executable. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "py"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_model_path"; + token.key_prefix = "--"; + token.label = "CrYOLO model path"; + token.help = "Path to the CrYOLO model file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_config_path"; + token.key_prefix = "--"; + token.label = "CrYOLO config path"; + token.help = "Path to the CrYOLO config file. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_json"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_gpu"; + token.key_prefix = "--"; + token.label = "CrYOLO GPUs"; + token.help = "Numbers of the GPUs to use seperated by commas. -1 is used for the CPU version. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "isac2_img_per_grp"; + token.key_prefix = "--"; + token.label = "ISAC2 images per group"; + token.help = "Number of images per group. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; + token.default = "100"; + token.restore = [['100'], ['100']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_predict_path"; + token.key_prefix = "--"; + token.label = "Cinderella predict path"; + token.help = "Path to the Cinderella executable. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_model_path"; + token.key_prefix = "--"; + token.label = "Cinderella model path"; + token.help = "Path to trained Cinderella model. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_any_h5"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "mpi_procs"; + token.key_prefix = "--"; + token.label = "MPI processors"; + token.help = "Number of processors you want to use for auto SPHIRE. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_job_name"; + token.key_prefix = "--"; + token.label = "MPI job name"; + token.help = "Name of the submission job. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "auto_sphire"; + token.restore = [['auto_sphire'], ['auto_sphire']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_submission_command"; + token.key_prefix = "--"; + token.label = "MPI Submission command"; + token.help = "Submission command to execute the Auto SPHIRE job "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "none"; + token.restore = [['none', 'sbatch', 'qsub'], ['none', 'sbatch', 'qsub']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "mpi_submission_template"; + token.key_prefix = "--"; + token.label = "MPI Submission script template"; + token.help = "Template to submit the job to a queue. "; + token.group = "main"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = "msgui_template.sh"; + token.restore = [['msgui_template.sh'], ['msgui_template.sh']]; + token.type = "params_any_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "skip_unblur"; + token.key_prefix = "--"; + token.label = "Skip UNBLUR"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "unblur_output_dir"; + token.key_prefix = "--"; + token.label = "UNBLUR output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "UNBLUR"; + token.restore = [['UNBLUR'], ['UNBLUR']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "unblur_addition"; + token.key_prefix = "--"; + token.label = "UNBLUR addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_cter"; + token.key_prefix = "--"; + token.label = "Skip CTER"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cter_mic_pattern"; + token.key_prefix = "--"; + token.label = "CTER input pattern"; + token.help = "Pattern of the cter input pattern. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_cter', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cter_window_size"; + token.key_prefix = "--"; + token.label = "CTER window size"; + token.help = "Window size for the CTF estimation. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; + token.default = "1024"; + token.restore = [['1024'], ['1024']]; + token.type = "ctfwin"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cter_output_dir"; + token.key_prefix = "--"; + token.label = "CTER output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; + token.default = "CTER"; + token.restore = [['CTER'], ['CTER']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cter_addition"; + token.key_prefix = "--"; + token.label = "CTER addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cter', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_cryolo"; + token.key_prefix = "--"; + token.label = "Skip CrYOLO"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cryolo_mic_path"; + token.key_prefix = "--"; + token.label = "CRYOLO micrograph path"; + token.help = "Path of the cryolo input images. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_cryolo', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "dir"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_output_dir"; + token.key_prefix = "--"; + token.label = "CRYOLO output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "CRYOLO_PREDICT"; + token.restore = [['CRYOLO_PREDICT'], ['CRYOLO_PREDICT']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cryolo_addition"; + token.key_prefix = "--"; + token.label = "CRYOLO addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_window"; + token.key_prefix = "--"; + token.label = "Skip WINDOW"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "window_box_pattern"; + token.key_prefix = "--"; + token.label = "WINDOW input box pattern"; + token.help = "Pattern of the box files. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cryolo', 'True', 'False'], ['skip_window', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_coords_any"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cryolo', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "window_mic_pattern"; + token.key_prefix = "--"; + token.label = "WINDOW input micrograph pattern"; + token.help = "Pattern of the input micrograph files. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_unblur', 'True', 'False'], ['skip_window', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "mic_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_unblur', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "window_partres"; + token.key_prefix = "--"; + token.label = "WINDOW partres file"; + token.help = "Path to the partres file. In case of negative stain use the pixel size value. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cter', 'True', 'False'], ['skip_window', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "params_cter_txt"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cter', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "window_output_dir"; + token.key_prefix = "--"; + token.label = "WINDOW output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_window', 'False', 'False']]; + token.default = "WINDOW"; + token.restore = [['WINDOW'], ['WINDOW']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "window_addition"; + token.key_prefix = "--"; + token.label = "WINDOW addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_window', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_isac2"; + token.key_prefix = "--"; + token.label = "Skip ISAC2"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "isac2_input_stack"; + token.key_prefix = "--"; + token.label = "ISAC2 input stack"; + token.help = "Stack used for ISAC2 "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_window', 'True', 'False'], ['skip_isac2', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_window', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "isac2_output_dir"; + token.key_prefix = "--"; + token.label = "ISAC2 output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; + token.default = "ISAC"; + token.restore = [['ISAC'], ['ISAC']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "isac2_addition"; + token.key_prefix = "--"; + token.label = "ISAC2 addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "substack_output_dir"; + token.key_prefix = "--"; + token.label = "ISAC2 substack output name"; + token.help = "Name of the output directory for the ISAC substack. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'False', 'False']]; + token.default = "SUBSTACK"; + token.restore = [['SUBSTACK'], ['SUBSTACK']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_cinderella"; + token.key_prefix = "--"; + token.label = "Skip Cinderella"; + token.help = "Skip automatic 2D class selection. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "cinderella_output_dir"; + token.key_prefix = "--"; + token.label = "Cinderella output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "AUTO2D"; + token.restore = [['AUTO2D'], ['AUTO2D']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_input_stack"; + token.key_prefix = "--"; + token.label = "Cinderella input stack"; + token.help = "Path to ISAC class stack "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_conf_thresh"; + token.key_prefix = "--"; + token.label = "Cinderella confidence threshold"; + token.help = "Classes with a confidence higher as that threshold are classified as good. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "0.5"; + token.restore = [['0.5'], ['0.5']]; + token.type = "float"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_gpu"; + token.key_prefix = "--"; + token.label = "Cinderella GPU ID"; + token.help = "ID of the GPU to run on. -1 will choose a GPU automatically. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "0"; + token.restore = [['0'], ['0']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "cinderella_batch_size"; + token.key_prefix = "--"; + token.label = "Cinderella Batch size"; + token.help = "Number of images in one batch during prediction. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_cinderella', 'False', 'False']]; + token.default = "32"; + token.restore = [['32'], ['32']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_cinderella', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_rviper"; + token.key_prefix = "--"; + token.label = "Skip RVIPER"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "rviper_use_final"; + token.key_prefix = "--"; + token.label = "RVIPER use final result"; + token.help = "Whether to use the first volume of the first iteration or the last volume of the last iteration "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'True', 'False'], ['skip_rviper', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "rviper_input_stack"; + token.key_prefix = "--"; + token.label = "RVIPER input stack"; + token.help = "Stack used for RVIPER "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_isac2', 'True', 'False'], ['skip_rviper', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data2d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']); + sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "rviper_output_dir"; + token.key_prefix = "--"; + token.label = "RVIPER output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_rviper', 'False', 'False']]; + token.default = "RVIPER"; + token.restore = [['RVIPER'], ['RVIPER']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "rviper_addition"; + token.key_prefix = "--"; + token.label = "RVIPER Addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_rviper', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_adjust_rviper"; + token.key_prefix = "--"; + token.label = "Skip ADJUST_RVIPER"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "adjust_rviper_resample"; + token.key_prefix = "--"; + token.label = "ADJUST_RVIPER resample ratio"; + token.help = "Resample ratio or ISAC directory "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False'], + ['skip_isac2', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "adjust_rviper_output_dir"; + token.key_prefix = "--"; + token.label = "ADJUST_RVIPER output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False']]; + token.default = "RVIPER_ADJUSTMENT"; + token.restore = [['RVIPER_ADJUSTMENT'], ['RVIPER_ADJUSTMENT']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "adjust_rviper_addition"; + token.key_prefix = "--"; + token.label = "ADJUST_RVIPER addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_adjust_rviper', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_mask_rviper"; + token.key_prefix = "--"; + token.label = "Skip MASK_RVIPER"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_adjustment_rviper', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "mask_rviper_ndilation"; + token.key_prefix = "--"; + token.label = "MASK_RVIPER ndilation"; + token.help = "Number of dilations. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], + ['skip_adjustment_rviper', 'False', 'False']]; + token.default = "5"; + token.restore = [['5'], ['5']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "mask_rviper_soft_edge"; + token.key_prefix = "--"; + token.label = "MASK_RVIPER soft edge"; + token.help = "Number of pixels for the soft edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], + ['skip_adjustment_rviper', 'False', 'False']]; + token.default = "10"; + token.restore = [['10'], ['10']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "mask_rviper_output_dir"; + token.key_prefix = "--"; + token.label = "MASK_RVIPER output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], + ['skip_adjustment_rviper', 'False', 'False']]; + token.default = "RVIPER_MASK"; + token.restore = [['RVIPER_MASK'], ['RVIPER_MASK']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "mask_rviper_addition"; + token.key_prefix = "--"; + token.label = "MASK_RVIPER addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_mask_rviper', 'False', 'False'], + ['skip_adjustment_rviper', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_adjustment_rviper', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_meridien"; + token.key_prefix = "--"; + token.label = "Skip MERIDIEN"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "meridien_input_volume"; + token.key_prefix = "--"; + token.label = "MERIDIEN input volume"; + token.help = "Input volume path. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_adjust_rviper', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_adjust_rviper', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "meridien_input_stack"; + token.key_prefix = "--"; + token.label = "MERIDIEN input stack"; + token.help = "Inpust particle stack. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_isac2', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_isac2', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "meridien_input_mask"; + token.key_prefix = "--"; + token.label = "MERIDIEN input mask"; + token.help = "3D Mask file. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_mask_rviper', 'True', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "data3d_one"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_mask_rviper', []).append([token.key_base, 'True', 'False']) + token = SXcmd_token(); + token.key_base = "meridien_output_dir"; + token.key_prefix = "--"; + token.label = "MERIDIEN output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; + token.default = "MERIDIEN"; + token.restore = [['MERIDIEN'], ['MERIDIEN']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "meridien_addition"; + token.key_prefix = "--"; + token.label = "MERIDIEN addititions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_sharpening_meridien"; + token.key_prefix = "--"; + token.label = "Skip SHARPENING_MERIDIEN"; + token.help = "Skip the movie alignment in case that you already have aligned movies. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "sharpening_meridien_ndilation"; + token.key_prefix = "--"; + token.label = "SHARPENING_MERIDIEN ndilation"; + token.help = "Number of dilations. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], + ['skip_meridien', 'False', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "sharpening_meridien_soft_edge"; + token.key_prefix = "--"; + token.label = "SHARPENING_MERIDIEN soft edge"; + token.help = "Number of pixels for the soft edge. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], + ['skip_meridien', 'False', 'False']]; + token.default = "8"; + token.restore = [['8'], ['8']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "sharpening_meridien_output_dir"; + token.key_prefix = "--"; + token.label = "SHARPENING_MERIDIEN output name"; + token.help = "Name of the output directory. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], + ['skip_meridien', 'False', 'False']]; + token.default = "SHARPENING"; + token.restore = [['SHARPENING'], ['SHARPENING']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "sharpening_meridien_addition"; + token.key_prefix = "--"; + token.label = "SHARPENING_MERIDIEN additions"; + token.help = "Optional additional arguments. "; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_sharpening_meridien', 'False', 'False'], + ['skip_meridien', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_sharpening_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_restack"; + token.key_prefix = "--"; + token.label = "Skip RESTACKING"; + token.help = "Skip restacking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "restack_output_dir"; + token.key_prefix = "--"; + token.label = "RESTACKING output name"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "RESTACK"; + token.restore = [['RESTACK'], ['RESTACK']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_addition"; + token.key_prefix = "--"; + token.label = "RESTACKING additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_window_output_dir"; + token.key_prefix = "--"; + token.label = "RESTACKING_WINDOW output dir"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "RESTACK_WINDOW"; + token.restore = [['RESTACK_WINDOW'], ['RESTACK_WINDOW']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_window_mic_pattern"; + token.key_prefix = "--"; + token.label = "RESTACKING_WINDOW mic pattern"; + token.help = "Micrograph pattern for restacking."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_window_partres"; + token.key_prefix = "--"; + token.label = "RESTACKING_WINDOW partres file"; + token.help = "Partres file"; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "bdb2d_stack"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_window_addition"; + token.key_prefix = "--"; + token.label = "RESTACKING_WINDOW additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_meridien_output_dir"; + token.key_prefix = "--"; + token.label = "RESTACKING_MERIDIEN output dir"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "RESTACK_MERIDIEN"; + token.restore = [['RESTACK_MERIDIEN'], ['RESTACK_MERIDIEN']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_meridien_addition"; + token.key_prefix = "--"; + token.label = "RESTACKING_MERIDIEN additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_sharpening_ndilation"; + token.key_prefix = "--"; + token.label = "RESTACKING_SHARPENING ndilation"; + token.help = "Number of dilations of the mask. 1 Dilation adds about 2 pixel to the binary volume."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_sharpening_soft_edge"; + token.key_prefix = "--"; + token.label = "RESTACKING_SHARPENING soft edge"; + token.help = "Number of pixels for the soft edge."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "8"; + token.restore = [['8'], ['8']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_sharpening_output_dir"; + token.key_prefix = "--"; + token.label = "RESTACKING_SHARPENING output dir"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "RESTACK_SHARPENING"; + token.restore = [['RESTACK_SHARPENING'], ['RESTACK_SHARPENING']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "restack_sharpening_addition"; + token.key_prefix = "--"; + token.label = "RESTACKING_SHARPENING additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], + ['skip_restack', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "skip_ctf_refine"; + token.key_prefix = "--"; + token.label = "Skip CTF_REFINE"; + token.help = "Skip CTF refinement."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + token = SXcmd_token(); + token.key_base = "ctf_refine_output_dir"; + token.key_prefix = "--"; + token.label = "CTF_REFINE output name"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "CTF_REFINE"; + token.restore = [['CTF_REFINE'], ['CTF_REFINE']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_refine_addition"; + token.key_prefix = "--"; + token.label = "CTF_REFINE additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_meridien_output_dir"; + token.key_prefix = "--"; + token.label = "CTF_MERIDIEN output name"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "CTF_MERIDIEN"; + token.restore = [['CTF_MERIDIEN'], ['CTF_MERIDIEN']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_meridien_addition"; + token.key_prefix = "--"; + token.label = "CTF_MERIDIEN additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_sharpening_ndilation"; + token.key_prefix = "--"; + token.label = "CTF_SHARPENING ndilation"; + token.help = "Number of dilations of the mask. 1 Dilation adds about 2 pixel to the binary volume."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "2"; + token.restore = [['2'], ['2']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_sharpening_soft_edge"; + token.key_prefix = "--"; + token.label = "CTF_SHARPENING soft edge"; + token.help = "Number of pixels for the soft edge."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "8"; + token.restore = [['8'], ['8']]; + token.type = "int"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_sharpening_output_dir"; + token.key_prefix = "--"; + token.label = "CTF_SHARPENING output name"; + token.help = "Restacking output directory."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "CTF_SHARPENING"; + token.restore = [['CTF_SHARPENING'], ['CTF_SHARPENING']]; + token.type = "output"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "ctf_sharpening_addition"; + token.key_prefix = "--"; + token.label = "CTF_SHARPENING additions"; + token.help = "Additional parameters that are not part of the required ones."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', ''], ['skip_meridien', 'False', 'False'], ['skip_restack', 'False', 'False'], + ['skip_ctf_refine', 'False', 'False']]; + token.default = "none"; + token.restore = [['none'], ['none']]; + token.type = "string"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token; + sxcmd.dependency_dict.setdefault('skip_meridien', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_restack', []).append([token.key_base, 'False', 'False']); + sxcmd.dependency_dict.setdefault('skip_ctf_refine', []).append([token.key_base, 'False', 'False']) + token = SXcmd_token(); + token.key_base = "dry_run"; + token.key_prefix = "--"; + token.label = "Dry run"; + token.help = "Do not submit the submission file, but just execute the command in order to create the submission file."; + token.group = "advanced"; + token.is_required = False; + token.is_locked = False; + token.is_reversed = False; + token.filament_tab = ""; + token.dependency_group = [['', '', '']]; + token.default = False; + token.restore = [[False], [False]]; + token.type = "bool"; + sxcmd.token_list.append(token); + sxcmd.token_dict[token.key_base] = token + + sxcmd_list.append(sxcmd) + + sxcmd = SXcmd(); + sxcmd.name = "transphire"; + sxcmd.subname = ""; + sxcmd.mode = ""; + sxcmd.subset_config = ""; + sxcmd.label = "TranSPHIRE GUI"; + sxcmd.short_info = "Automated data pre-processing. TranSPHIRE needs to be installed seperately and the transphire executable needs to be present in the PATH: https:github.com/MPI-Dortmund/transphire"; + sxcmd.mpi_support = False; + sxcmd.mpi_add_flag = False; + sxcmd.category = "sxc_utilities"; + sxcmd.role = "sxr_util"; + sxcmd.is_submittable = False sxcmd_list.append(sxcmd) @@ -7039,9 +37151,10 @@ def construct_sxcmd_category_list(self): for sxcmd_token in sxcmd.token_list: # Handle very special cases if sxcmd_token.type == "user_func": - n_widgets = 2 # function type has two line edit boxes + n_widgets = 2 # function type has two line edit boxes sxcmd_token.label = [sxcmd_token.label, "Python script for user function"] - sxcmd_token.help = [sxcmd_token.help, "Please leave it none/blank if file is not external to SPHIRE"] + sxcmd_token.help = [sxcmd_token.help, + "Please leave it none/blank if file is not external to SPHIRE"] sxcmd_token.default = sxcmd_token.default.split('|||') if not sxcmd_token.is_locked: sxcmd_token.restore = [sxcmd_token.restore, [["none"], ["none"]]] @@ -7069,7 +37182,8 @@ def update_qsub_enable_states(self): sxcmd.widget.sxcmd_tab_main.set_qsub_enable_state() def handle_sxmenu_item_btn_event(self, sxmenu_item, i=0): - assert(isinstance(sxmenu_item, SXmenu_item) == True) # Assuming the sxmenu_item is an instance of class SXmenu_item + assert (isinstance(sxmenu_item, + SXmenu_item) == True) # Assuming the sxmenu_item is an instance of class SXmenu_item modifiers = QApplication.keyboardModifiers() if modifiers == Qt.ShiftModifier: @@ -7096,7 +37210,7 @@ def handle_sxmenu_item_btn_event(self, sxmenu_item, i=0): self.sxmenu_item_widget_stacked_layout[self.helical].setCurrentWidget(self.cur_sxmenu_item.widget) def closeEvent(self, event): - event.ignore() # event.accept() + event.ignore() # event.accept() # Quit child applications of all sxcmd widgets for idx in range(2): @@ -7106,8 +37220,9 @@ def closeEvent(self, event): print("bye bye") QtCore.QCoreApplication.instance().quit() - # def changeEvent(self, event): - # print(self.frameGeometry()) + +# def changeEvent(self, event): +# print(self.frameGeometry()) # ======================================================================================== @@ -7117,15 +37232,16 @@ def main(): The main SPHIRE GUI application. It is designed as the command generator for the SPHIRE single particle analysis pipeline. """ parser = OptionParser(usage, version=sp_global_def.SPARXVERSION) - parser.add_option('--helical', action='store_true', default=False, help='Start the GUI in helical mode. This can be changed after the start. (default False)') + parser.add_option('--helical', action='store_true', default=False, + help='Start the GUI in helical mode. This can be changed after the start. (default False)') # No options!!! Does not need to call parser.add_option() - + (options, args) = parser.parse_args(sys.argv[1:]) - + if len(args) > 1: print("see usage " + usage) sys.exit() - + sxapp = QApplication(sys.argv) # The valid keys can be retrieved using the keys() function. # Typically they include "windows", "motif", "cde", "plastique" and "cleanlooks". @@ -7150,7 +37266,7 @@ def main(): sxapp_font = sxapp.font() sxapp_font_info = QFontInfo(sxapp.font()) -# new_point_size = sxapp_font_info.pointSize() + 1 + # new_point_size = sxapp_font_info.pointSize() + 1 new_point_size = sxapp_font_info.pointSize() # # MRK_DEBUG: Check the default system font # print "MRK_DEBUG: sxapp_font_info.style() = ", sxapp_font_info.style() @@ -7170,8 +37286,8 @@ def main(): # still showing the default font size: # QPushButton, QLable, Window Title, and QToolTip # -# sxapp_font.setPointSize(new_point_size) # and setPointSizeF() are device independent, while setPixelSize() is device dependent -# sxapp.setFont(sxapp_font) + # sxapp_font.setPointSize(new_point_size) # and setPointSizeF() are device independent, while setPixelSize() is device dependent + # sxapp.setFont(sxapp_font) # sxapp.setStyleSheet("QPushButton {font-size:18pt;}"); # NOTE: 2016/02/19 Toshio Moriya: Doesn't work # sxapp.setStyleSheet("QLabel {font-size:18pt;}"); # NOTE: 2016/02/19 Toshio Moriya: Doesn't work @@ -7180,7 +37296,7 @@ def main(): # Initialise a singleton class for look & feel constants - version_string = '1.4' #### sphire.__version__# + version_string = '1.4' #### sphire.__version__# SXLookFeelConst.initialise(sxapp, version_string) # Define the main window (class SXMainWindow) @@ -7201,6 +37317,7 @@ def main(): # Start event handling loop sxapp.exec_() + # ======================================================================================== if __name__ == "__main__": print() diff --git a/sphire/sphire/bin/sp_header.py b/sphire/sphire/bin/sp_header.py index 226ad0388b..87baa10507 100755 --- a/sphire/sphire/bin/sp_header.py +++ b/sphire/sphire/bin/sp_header.py @@ -42,9 +42,9 @@ # import optparse -from ..libpy import sp_applications -from ..libpy import sp_global_def -from ..libpy import sp_utilities +from sphire.libpy import sp_applications +from sphire.libpy import sp_global_def +from sphire.libpy import sp_utilities import sys diff --git a/sphire/sphire/bin/sp_higher_ord_abber.py b/sphire/sphire/bin/sp_higher_ord_abber.py new file mode 100644 index 0000000000..af33d3ea47 --- /dev/null +++ b/sphire/sphire/bin/sp_higher_ord_abber.py @@ -0,0 +1,810 @@ +#!/usr/bin/env python +## +import tqdm +import os +import subprocess +import sys +import argparse +import time +import json +from glob import glob +import numpy as np +import pandas as pd +import shutil + +try: + from ..libpy import sp_global_def + from ..libpy import sp_utilities +except: + from sphire.libpy import sp_global_def + from sphire.libpy import sp_utilities + +try: + from pyStarDB import sp_pystardb as star +except: + print("Please install pyStarDB package using pip in order to run this tool") + + +def parse_parameters(args): + parser = argparse.ArgumentParser(args, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser.add_argument( + "post_refiner", + type=str, + help="post refiner directory", + ) + + parser.add_argument( + "Output_folder", + type=str, + help="output_directory", + ) + + parser.add_argument( + "--estimate_magnification", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--estimate_beamtilt", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--estimate_trefoil", + action="store_true", + help="If set to True, then relion_ctf_refine will also estimate the trefoil (3-fold astigmatism) per optics group." + "This option is only recommended for data sets that extend beyond 3.5 Angstrom resolution", + default=False + ) + + parser.add_argument( + "--estimate_order_aberation", + action="store_true", + help="4th order aberration", + default=False + ) + + parser.add_argument( + "--perform_CTF_params_fit", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_defocus_micrograph", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_defocus_particle", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_astigmatism_micrograph", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_astigmatism_particle", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_bfactor_micrograph", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_bfactor_particle", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_phase_shift_micrograph", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--fit_phase_shift_particle", + action="store_true", + help="", + default=False + ) + + parser.add_argument( + "--min_res_fit", + type=float, + help="", + default=30.0 + ) + + parser.add_argument( + "--submission_template", + type = str, + help ="", + default = None + ) + + parser.add_argument( + "--submission_command", + type=str, + help="", + default="sbatch" + ) + + parser.add_argument( + "--relion_mpirun_executable", + type=str, + help="", + default="mpirun" + ) + + parser.add_argument( + "--relion_ctfrefine_executable", + type=str, + help="", + default="relion_ctf_refine_mpi" + ) + + parser.add_argument( + "--mpi_procs", + type= int, + help ="", + default = 1 + ) + + parser.add_argument( + "--no_of_threads", + type=int, + help="", + default= 1, + ) + + parser.add_argument( + "--mrc_reloc_folder", + type=str, + help="", + default= None + ) + + return parser.parse_args() + + +def get_final_iter(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['best'] + + +def get_bdb_loc(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['stack'] + + +def sanity_function_check(input_folder): + # This is important and will be written as soon as the post refiner part is done. + pass + + +def get_final_iter_files(input_folder): + sanity_function_check(input_folder) + if os.path.isdir(input_folder): + if os.path.exists(os.path.join(input_folder, 'Tracker_final.json')): + tracker_file = os.path.join(input_folder, 'Tracker_final.json') + use_iter = 1 + else: + main_directory = sorted(glob(os.path.join(input_folder, 'main*')))[-1] + tracker_file = glob(os.path.join(main_directory, 'Tracker_*.json'))[0] + use_iter = -1 + + if use_iter == 1: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + else: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + template = '{0}_{1:03d}.{2}' + required_data = [['params', 'txt'], ['chunk_0', 'txt'], ['chunk_1', 'txt']] + required_files = [] + for i, j in required_data: + required_files.append(os.path.join(tracker_file, template.format(i, final_iter, j))) + return required_files, bdbfile + + +def parse_postrefiner(args_post): + parser_post = argparse.ArgumentParser(args_post, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser_post.add_argument( + "command_python", + type=str, + help="", + ) + + parser_post.add_argument( + "--combinemaps", + type=str, + help="", + nargs=2 + ) + + parser_post.add_argument( + "--output_dir", + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--pixel_size", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--mask", + default=None, + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--do_adaptive_mask", + help="", + action='store_true', + ) + + parser_post.add_argument( + "--threshold", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--edge_width", + type=int, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--ndilation", + type=int, + help="", + ) + + parser_post.add_argument( + "--mtf", + type=str, + help="", + default = None, + nargs=1 + ) + + parser_post.add_argument( + "--B_enhance", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--f", + type=float, + help="", + nargs=1 + ) + + return parser_post.parse_args(args_post.split()) + + +def run(args): + options = parse_parameters(args) + ################################################# + ############Post process call################# + ################################################# + ###### Post process part starts here + if os.path.isdir(options.post_refiner): + with open(os.path.join(options.post_refiner, 'command.txt'), 'r') as commandfile: + read_command_txt = commandfile.read() + + post_refine_options = parse_postrefiner(read_command_txt) + + if post_refine_options.mask != None: + use_mask = post_refine_options.mask[0] + else: + use_mask = os.path.join(options.post_refiner, 'vol_adaptive_mask.hdf') + + try: + shutil.rmtree(os.path.join(str(options.Output_folder),'PostProcess')) + except FileNotFoundError: + os.makedirs( os.path.join(str(options.Output_folder),'PostProcess')) + pass + + pp_star_file = star.StarFile(os.path.join( os.path.join(str(options.Output_folder),'PostProcess'), + 'postprocess.star')) + + half_map1 = post_refine_options.combinemaps[0] + half_map2 = post_refine_options.combinemaps[1] + + if half_map1.endswith('hdf'): + half_1_call = ( + "e2proc3d.py" + + " " + str(half_map1) + + " " + str(half_map1).replace('hdf', 'mrc') + ) + + half_2_call = ( + "e2proc3d.py" + + " " + str(half_map2) + + " " + str(half_map2).replace('hdf', 'mrc') + ) + subprocess.run(args=[half_1_call], shell=True, text=True) + subprocess.run(args=[half_2_call], shell=True, text=True) + half_map1 = half_map1.replace('hdf', 'mrc') + half_map2 = half_map2.replace('hdf', 'mrc') + + + if use_mask.endswith('hdf'): + mask_call = ( + "e2proc3d.py" + + " " + str(use_mask) + + " " + str(use_mask).replace('hdf', 'mrc') + ) + subprocess.run(args=[mask_call], shell=True, text=True) + use_mask = use_mask.replace('hdf', 'mrc') + + general_pp = pd.DataFrame([[half_map1, half_map2, use_mask]], + columns=['_rlnUnfilteredMapHalf1', '_rlnUnfilteredMapHalf2', '_rlnMaskName']) + + pp_star_file.update('general', general_pp, False) + + fsc_halves = np.loadtxt( os.path.join(options.post_refiner, 'halves.txt')) + fsc_masked_halves = np.loadtxt(os.path.join(options.post_refiner, 'masked_halves.txt')) + fsc_full = np.loadtxt( os.path.join(options.post_refiner, 'full.txt')) + + spectral_index = fsc_halves[:, 0] + angs_resolution = fsc_halves[:, 1] + resolution = np.divide(1, angs_resolution) + fsc_corrected = fsc_full[:, 2] + fsc_unmasked_maps = fsc_halves[:, 2] + fsc_masked_maps = fsc_masked_halves[:, 2] + + fsc_data_pp = pd.DataFrame(np.array([spectral_index, resolution, angs_resolution, fsc_corrected, + fsc_unmasked_maps, fsc_masked_maps]).swapaxes(0, 1).tolist(), + columns=['_rlnSpectralIndex', '_rlnResolution', '_rlnAngstromResolution', + '_rlnFourierShellCorrelationCorrected', + '_rlnFourierShellCorrelationUnmaskedMaps', + '_rlnFourierShellCorrelationMaskedMaps' + ]) + + for col in fsc_data_pp.columns: + if col == '_rlnSpectralIndex': + fsc_data_pp[col] = fsc_data_pp[col].map(lambda x: int(x)) + else: + fsc_data_pp[col] = fsc_data_pp[col].map(lambda x: '{0:0.4f}'.format(x)) + + pp_star_file.update('fsc', fsc_data_pp, True) + + guiner = np.loadtxt(os.path.join(options.post_refiner, 'guinierlines.txt'), skiprows=1) + if post_refine_options.mtf != None: + resol_sq = guiner[:, 0] + log_amp_orig = guiner[:, 1] + log_amp_weight = guiner[:, 2] + log_amp_sharpened = guiner[:, 3] + + guiner_data_pp = pd.DataFrame( + np.array([resol_sq, log_amp_orig, log_amp_weight, log_amp_sharpened]).swapaxes(0, 1).tolist(), + columns=['_rlnResolutionSquared', '_rlnLogAmplitudesOriginal', '_rlnLogAmplitudesWeighted', + '_rlnLogAmplitudesSharpened' + ]) + else : + resol_sq = guiner[:, 0] + log_amp_orig = guiner[:, 1] + log_amp_weight = guiner[:, 2] + + guiner_data_pp = pd.DataFrame( + np.array([resol_sq, log_amp_orig, log_amp_weight]).swapaxes(0, 1).tolist(), + columns=['_rlnResolutionSquared', '_rlnLogAmplitudesOriginal', '_rlnLogAmplitudesSharpened' + ]) + + pp_star_file.update('guiner', guiner_data_pp, True) + pp_star_file.write_star_file() + + ##### Post Process part ends here + + ################################################# + ############SPHIRE 2 RELION################# + ################################################# + ###### SPHIRE 2 RELION Parts starts here + meridien_folder = post_refine_options.combinemaps[0].split('/vol')[0] + iter_files, bdbfile = get_final_iter_files(meridien_folder) + ##Note sphire2relion requires the 3dparams file and the chunk + + if os.path.isdir(meridien_folder): + sph2rel_call = ( + "sp_sphire2relion.py" + + " " + os.path.join(str(options.Output_folder), "BDB2STAR") + + " " + "--particle_stack=" + str(bdbfile) + + " " + "--params_3d_file=" + str(iter_files[0]) + + " " + "--params_3d_chunk_file_0=" + str(iter_files[1]) + + " " + "--params_3d_chunk_file_1=" + str(iter_files[2]) + ) + + subprocess.run(args=[sph2rel_call], shell=True, text=True) + + if options.mrc_reloc_folder != None: + bdb_star = star.StarFile(os.path.join( os.path.join(str(options.Output_folder), "BDB2STAR"), + 'sphire2relion.star')) + old_micrograph_name = bdb_star[""]['_rlnMicrographName'] + new_micrograph_name = old_micrograph_name.apply(lambda x: os.path.join(options.mrc_reloc_folder + , os.path.basename(x) + )) + bdb_star[""]['_rlnMicrographName'] = new_micrograph_name + + bdb_star.write_star_file(overwrite=True) + + + """ + Till here it is generic script where we convert the stack and create the postprocess star file. + """ + flag_defocus ='f' + flag_astig = 'f' + flag_bfactor = 'f' + flag_phase_shift = 'f' + total_flag = "" + + if options.estimate_magnification: + total_flag += "--fit_aniso" + " " + "--kmin_mag " + str(options.min_res_fit) + else: + if options.perform_CTF_params_fit: + if options.fit_defocus_micrograph: + flag_defocus = 'm' + total_flag += "--fit_defocus" + " " + "--kmin_defocus " + str(options.min_res_fit) + elif options.fit_defocus_particle: + flag_defocus = 'p' + total_flag += "--fit_defocus" + " " + "--kmin_defocus " + str(options.min_res_fit) + else: + pass + + if options.fit_astigmatism_micrograph: + flag_astig = 'm' + elif options.fit_astigmatism_particle: + flag_astig = 'p' + else : + pass + + if options.fit_bfactor_micrograph: + flag_bfactor = 'm' + elif options.fit_bfactor_particle: + flag_bfactor = 'p' + else : + pass + + if options.fit_phase_shift_micrograph: + flag_phase_shift = 'm' + elif options.fit_phase_shift_particle: + flag_phase_shift = 'p' + else : + pass + + fit_mode = flag_phase_shift + flag_defocus + flag_astig + 'f' + flag_bfactor + total_flag += " " + "--fit_mode " + str(fit_mode) + else : + pass + + if options.estimate_beamtilt and not options.estimate_trefoil: + total_flag += " " + "--fit_beamtilt" + " " + "--kmin_tilt " + str(options.min_res_fit) + elif options.estimate_beamtilt and options.estimate_trefoil : + total_flag += " " + "--fit_beamtilt" + " " + "--kmin_tilt " + str(options.min_res_fit) + " " + "--odd_aberr_max_n 3" + else : + pass + + if options.estimate_order_aberation: + total_flag += " " + "--fit_aberr" + else : + pass + + print("flags for the all commands is", total_flag) + print("pixel size obtained is" , post_refine_options.pixel_size[0]) + time.sleep(5) + + ### now we need to decide we want to run it on a single PC workstation or on cluster + if options.submission_template != None: + ctfrefine_call = options.relion_ctfrefine_executable\ + + " --i " + os.path.join(options.Output_folder,"BDB2STAR/sphire2relion.star")\ + + " " + "--f " + os.path.join(str(options.Output_folder), "PostProcess/postprocess.star")\ + + " " + "--o " + str(options.Output_folder) \ + + " " + total_flag \ + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) \ + + " " + "--j " + str(options.no_of_threads) + + try: + with open(options.submission_template) as read: + lines = read.readlines() + except Exception as e: + sp_global_def.ERROR(str(e) + '\nCannot open mpi_submission template!', action=1) + + cmd_lines = [] + for idx, entry in enumerate(lines): + if "XXX_SXCMD_LINE_XXX" in entry and "mpirun" in entry: + cmd_lines.append(idx) + + if not cmd_lines: + sp_global_def.sxprint("Could not find a suitable command line for exchange.") + sp_global_def.sxprint("The line should contain XXX_SXCMD_LINE_XXX.") + sys.exit(1) + + line = (lines[cmd_lines[-1]].replace("XXX_SXCMD_LINE_XXX", ctfrefine_call )) + + mod_sub_script = "".join(lines).replace("XXX_SXMPI_NPROC_XXX", str(options.mpi_procs) + ).replace("XXX_SXMPI_JOB_NAME_XXX", "sp_higher_ord_abber" + ).replace(lines[cmd_lines[-1]], line + ).replace("mpirun", options.relion_mpirun_executable) + + out_submission = "{0}/ctfrefine_submission_script.sh".format(str(options.Output_folder)) + with open(out_submission, "w") as w: + w.write("".join(mod_sub_script)) + + sp_global_def.sxprint( + subprocess.check_output( + options.submission_command.split() + [out_submission] + ) + ) + + else: + if options.mpi_procs > 1 : + # if we want to run it on a workstation + import mpi + os.unsetenv('OMPI_COMM_WORLD_RANK') + RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + if RUNNING_UNDER_MPI: + mpi.mpi_init(0, []) + rank = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) + size = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD) + else: + rank = 0 + size = 1 + + env = os.environ + new_env = {k: v for k, v in env.items() if "MPI" not in k} + + + ctfrefine_call = ( + "mpirun" + + " " + "-np" + + " " + str(options.mpi_procs) + + " " + options.relion_ctfrefine_executable + + " --i " + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--f " + os.path.join(str(options.Output_folder), "PostProcess/postprocess.star") + + " " + "--o " + str(options.Output_folder) + + " " + total_flag + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) + + " " + "--j " + str(options.no_of_threads) + ) + # rel2sph_call = ( + # "sp_relion2sphire.py" + # + " " + os.path.join(str(options.Output_folder), "shiny.star") + # + " " + "Polish_Stack" + # + " " + "--relion_project_dir='.'" + # + " " + "--box_size=-1" + # ) + + print("Ctf refine with mpi command is called", ctfrefine_call) + subprocess.run(args=[ctfrefine_call], shell=True, text= True, env=new_env) + # subprocess.run(args=[rel2sph_call], shell=True, text=True) + else : + ctfrefine_call = ( + options.relion_ctfrefine_executable + + " --i " + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--f " + os.path.join(str(options.Output_folder), "PostProcess/postprocess.star") + + " " + "--o " + str(options.Output_folder) + + " " + total_flag + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) + + " " + "--j " + str(options.no_of_threads) + ) + print("Ctf refine without mpi command is called", ctfrefine_call) + subprocess.run(args=[ctfrefine_call], shell=True, text=True) + + + +def main(): + + try: + sp_global_def.print_timestamp("Start") + run(sys.argv[1:]) + finally: + sp_global_def.print_timestamp("Finish") + + +if __name__ == "__main__": + main() + +#### + +# from pyStarDB import sp_pystardb as star +# import os +# import pandas as pd +# given_file = os.path.join('/home/adnan/DemoResults/Relion_CTF_REFINE_Test_v1/BDB2STAR/', +# 'sphire2relion.star') +# outputfile = os.path.join('/home/adnan/DemoResults/Relion_CTF_REFINE_Test_v1/BDB2STAR/','test_newfile.star') +# starfile = star.StarFile(given_file) +# +# a = [[0, 1], [2, 3]] +# dd = pd.DataFrame(a, columns=['_c1', '_c2']) +# starfile["newtag"] = dd +# +# starfile.write_star_file(outputfile, overwrite=True) + + +#### + +# try: +# from ..libpy import sp_global_def +# from ..libpy import sp_utilities +# except: +# from sphire.libpy import sp_global_def +# from sphire.libpy import sp_utilities +# import numpy +# from past.utils import old_div +# +# patres_file = '/home/adnan/DemoResults/CTFFIND4_v4.1.X_combined.txt' +# with open(patres_file, "r") as partres_reader: +# number_of_columns = len(partres_reader.readline().split()) +# +# if number_of_columns == 22: +# columns = [0, 1, 2, 3, 6, 7, 17, 19, 20, 21] +# dtype_import_list = [ +# ("defocus", float), +# ("cs", float), +# ("voltage", float), +# ("pixel_size", float), +# ("astig_amp", float), +# ("astig_angle", float), +# ("max_resolution", float), +# ("amplitude_contrast", float), +# ("phase_shift", float), +# ("micrograph_name", "|U1000"), +# ] +# dtype_output_list = [ +# ("_rlnDefocusU", float), +# ("_rlnDefocusV", float), +# ("_rlnDefocusAngle", float), +# ("_rlnMicrographName", "|U1000"), +# ("_rlnDetectorPixelSize", float), +# ("_rlnMagnification", float), +# ("_rlnCtfMaxResolution", float), +# ("_rlnPhaseShift", float), +# ("_rlnAmplitudeContrast", float), +# ("_rlnSphericalAberration", float), +# ("_rlnVoltage", float), +# ] +# else: +# sp_global_def.ERROR( +# "Number of columns in partres file not known: {0}".format( +# number_of_columns +# ), +# "sp_sphire2relion", +# ) +# +# assert len(columns) == len(dtype_import_list) +# partres_import_array = numpy.genfromtxt( +# patres_file, dtype=dtype_import_list, usecols=columns +# ) +# partres_data = numpy.empty( +# partres_import_array.shape[0], sorted(dtype_output_list) +# ) +# +# partres_data["_rlnDefocusU"] = old_div( +# ( +# 20000 * partres_import_array["defocus"] +# - 10000 * partres_import_array["astig_amp"] +# ), +# 2, +# ) +# partres_data["_rlnDefocusV"] = ( +# 20000 * partres_import_array["defocus"] - partres_data["_rlnDefocusU"] +# ) +# partres_data["_rlnDefocusAngle"] = 45 - partres_import_array["astig_angle"] +# partres_data["_rlnMicrographName"] = partres_import_array["micrograph_name"] +# partres_data["_rlnAmplitudeContrast"] = old_div( +# partres_import_array["amplitude_contrast"], 100 +# ) +# partres_data["_rlnVoltage"] = partres_import_array["voltage"] +# +# partres_import_array["cs"][partres_import_array["cs"] == 0] = 0.1 +# partres_data["_rlnSphericalAberration"] = partres_import_array["cs"] +# +# partres_data["_rlnPhaseShift"] = partres_import_array["phase_shift"] +# partres_data["_rlnDetectorPixelSize"] = partres_import_array["pixel_size"] +# partres_data["_rlnMagnification"] = 10000 +# partres_data["_rlnCtfMaxResolution"] = old_div( +# 1, partres_import_array["max_resolution"] +# ) +# +# output_dtype = [] +# output_dtype.extend(partres_data.dtype.descr) +# params_index_data = numpy.arange(partres_data.shape[0]) +# +# output_data = numpy.empty( +# params_index_data.shape[0], dtype=sorted(list(set(output_dtype))) +# ) +# +# if partres_data is not None: +# for row in partres_data: +# mask = output_data["_rlnMicrographName"] == row["_rlnMicrographName"] +# for name in partres_data.dtype.names: +# output_data[name][mask] = row[name] +# +# header = ["", "data_", "", "loop_"] +# header.extend( +# [ +# "{0} #{1}".format(name, idx + 1) +# for idx, name in enumerate(output_data.dtype.names) +# ] +# ) +# dtype_dict = output_data.dtype.fields +# fmt = [] +# for name in output_data.dtype.names: +# max_length = ( +# len( +# max([str(entry).split(".")[0] for entry in output_data[name]], key=len) +# ) +# + 2 +# ) +# if "float" in str(dtype_dict[name][0]): +# fmt.append("%{0}.6f".format(max_length + 7)) +# elif "int" in str(dtype_dict[name][0]): +# fmt.append("%{0}d".format(max_length)) +# elif "|U" in str(dtype_dict[name][0]) or " n_fullstack_img: sp_global_def.ERROR( "The number of entries in {} is not consistent with {} (the number of accounted particles is larger than ones of particles in the original fullstack). Please check the consistency of input datasets.".format( - accounted_local_total_align2d_path, args.input_bdb_stack_path + accounted_local_total_align2d_path, args.input_star_stack_path ), where=subcommand_name, ) # action=1 - fatal error, exit @@ -961,16 +962,17 @@ def isac_substack(args): # Create virtual stack for ISAC substack sp_global_def.sxprint(" ") sp_global_def.sxprint("Creating ISAC substack as a virtual stack...") - virtual_bdb_substack_path = "bdb:{}#{}".format( - args.output_directory, args.substack_basename - ) + # virtual_bdb_substack_path = "bdb:{}#{}".format( + # args.output_directory, args.substack_basename + # ) + virtual_star_substack_path = "{}/{}.star".format(args.output_directory, args.substack_basename) if args.min_nr_segments: - virtual_bdb_substack_path_tmp = "bdb:{}#{}_original".format(args.output_directory, args.substack_basename) + virtual_star_substack_path_tmp = "{}/{}_original.star".format(args.output_directory, args.substack_basename) else: - virtual_bdb_substack_path_tmp = virtual_bdb_substack_path - cmd_line = "e2bdb.py {} --makevstack={} --list={}".format( - args.input_bdb_stack_path, # source stack - virtual_bdb_substack_path_tmp, # target stack + virtual_star_substack_path_tmp = virtual_star_substack_path + cmd_line = "sp_star.py {} --makevstack={} --list={}".format( + args.input_star_stack_path, # source stack + virtual_star_substack_path_tmp, # target stack fullstack_img_id_path_of_isac_substack, ) # indices to denote which images in the source stack to add to the target stack status = sp_utilities.cmdexecute(cmd_line) @@ -985,7 +987,7 @@ def isac_substack(args): "Importing the total 2D alignment parameters in the original scale to the header entry..." ) cmd_line = "sp_header.py {} --import={} --params={}".format( - virtual_bdb_substack_path_tmp, # target stack + virtual_star_substack_path_tmp, # target stack isac_substack_total_header_align2d_path, # import sp_alignment parameters from .txt file "xform.align2d", ) # perform the import on the alignment parameters @@ -1000,7 +1002,7 @@ def isac_substack(args): sp_global_def.sxprint( "Creating projection parameters header entry from imported 2D alignment parameters using 2D-to-3D transformation..." ) - cmd_line = "sp_params_2D_to_3D.py {}".format(virtual_bdb_substack_path_tmp) + cmd_line = "sp_params_2D_to_3D.py {}".format(virtual_star_substack_path_tmp) status = sp_utilities.cmdexecute(cmd_line) if status == 0: sp_global_def.ERROR( @@ -1014,7 +1016,7 @@ def isac_substack(args): args.output_directory, "{}_header_projection.txt".format(args.substack_basename) ) cmd_line = "sp_header.py {} --export={} --params=xform.projection".format( - virtual_bdb_substack_path_tmp, isac_substack_total_header_projection_path + virtual_star_substack_path_tmp, isac_substack_total_header_projection_path ) status = sp_utilities.cmdexecute(cmd_line) if status == 0: @@ -1028,7 +1030,7 @@ def isac_substack(args): "Importing class membership information (also found in file 'particle_membership.txt')..." ) cmd_line = "sp_header.py {} --import={} --params={}".format( - virtual_bdb_substack_path_tmp, # target stack + virtual_star_substack_path_tmp, # target stack class_membership_file_path, # import sp_alignment parameters from .txt file "ISAC_class_id", ) # perform the import on the alignment parameters @@ -1050,11 +1052,11 @@ def isac_substack(args): sp_global_def.sxprint(" Extracted class members : %6d" % (n_isac_substack_img)) sp_global_def.sxprint( " ISAC substack size : %6d" - % (EMAN2_cppwrap.EMUtil.get_image_count(virtual_bdb_substack_path_tmp)) + % (EMAN2_cppwrap.EMUtil.get_image_count(virtual_star_substack_path_tmp)) ) if args.min_nr_segments: - args.input_stack_path = virtual_bdb_substack_path_tmp + args.input_stack_path = virtual_star_substack_path_tmp n_filaments, ori_n_filaments = reorder_filaments(args, overwrite=True) sp_global_def.sxprint(" ") sp_global_def.sxprint("Summary of processing...") @@ -2575,7 +2577,7 @@ def get_min_max_filament_coord(self, filament_id, centered): sp_global_def.BATCH = True # Check error conditions of arguments - if not EMAN2db.db_check_dict(args.input_bdb_stack_path, readonly=True): + if not EMAN2db.db_check_dict(args.input_star_stack_path, readonly=True): sp_global_def.ERROR( "Input BDB image stack file does not exist. Please check the input stack path and restart the program.", where=subcommand_name, @@ -2606,7 +2608,7 @@ def get_min_max_filament_coord(self, filament_id, centered): ) # action=1 - fatal error, exit if not args.reboxing: img = EMAN2_cppwrap.EMData() - img.read_image(args.input_bdb_stack_path, 0, True) + img.read_image(args.input_star_stack_path, 0, True) img_size = img.get_xsize() if abs(args.shift3d_x) >= old_div(img_size, 2): sp_global_def.ERROR( @@ -2736,13 +2738,13 @@ def get_min_max_filament_coord(self, filament_id, centered): # -------------------------------------------------------------------------------- sp_global_def.sxprint(" ") sp_global_def.sxprint( - "Checking the input stack {}...".format(args.input_bdb_stack_path) + "Checking the input stack {}...".format(args.input_star_stack_path) ) - n_img = EMAN2_cppwrap.EMUtil.get_image_count(args.input_bdb_stack_path) + n_img = EMAN2_cppwrap.EMUtil.get_image_count(args.input_star_stack_path) # sxprint(" ") sp_global_def.sxprint( "Found {} particle images in the input stack {}".format( - n_img, args.input_bdb_stack_path + n_img, args.input_star_stack_path ) ) @@ -2756,8 +2758,8 @@ def get_min_max_filament_coord(self, filament_id, centered): img = EMAN2_cppwrap.EMData() for img_id in range(n_img): # Load images - # img = get_im(args.input_bdb_stack_path, img_id) - img.read_image(args.input_bdb_stack_path, img_id, True) + # img = get_im(args.input_star_stack_path, img_id) + img.read_image(args.input_star_stack_path, img_id, True) # Extract associated source micrograph path name from the image header mic_path = str(img.get_attr("ptcl_source_image")) mic_basename = os.path.basename(mic_path) @@ -3025,13 +3027,13 @@ def get_min_max_filament_coord(self, filament_id, centered): global_mic_dict[mic_basename].centered_rebox_coords_list.append(line) # sxprint(" ") - # sxprint("Found total of {} assocaited micrographs in the input stack {}.".format(len(global_mic_dict), args.input_bdb_stack_path)) + # sxprint("Found total of {} assocaited micrographs in the input stack {}.".format(len(global_mic_dict), args.input_star_stack_path)) if missing_ctf_params_counter > 0: sp_global_def.sxprint(" ") sp_global_def.sxprint( "WARNING!!! The CTF parameters (ctf header entry) are missing from {} out of {} particle images in the input stack {}.".format( - missing_proj_params_counter, n_img, args.input_bdb_stack_path + missing_proj_params_counter, n_img, args.input_star_stack_path ) ) sp_global_def.sxprint( @@ -3042,7 +3044,7 @@ def get_min_max_filament_coord(self, filament_id, centered): sp_global_def.sxprint(" ") sp_global_def.sxprint( "WARNING!!! The projection parameters (xform.projection header entry) are missing from {} out of {} particle images in the input stack {}.".format( - missing_proj_params_counter, n_img, args.input_bdb_stack_path + missing_proj_params_counter, n_img, args.input_star_stack_path ) ) sp_global_def.sxprint( @@ -3084,7 +3086,7 @@ def get_min_max_filament_coord(self, filament_id, centered): sp_global_def.sxprint(" ") sp_global_def.sxprint( "Found total of {} micrographs in the input stack {}.".format( - len(mic_basename_list_of_input_stack), args.input_bdb_stack_path + len(mic_basename_list_of_input_stack), args.input_star_stack_path ) ) @@ -3106,7 +3108,7 @@ def get_min_max_filament_coord(self, filament_id, centered): ) sp_global_def.sxprint( "Saving the list of micrographs found in the input stack {} to {}...".format( - args.input_bdb_stack_path, input_mic_list_file_path + args.input_star_stack_path, input_mic_list_file_path ) ) input_mic_list_file = open(input_mic_list_file_path, "w") @@ -3340,12 +3342,12 @@ def get_min_max_filament_coord(self, filament_id, centered): # Create virtual stack for output stack sp_global_def.sxprint(" ") sp_global_def.sxprint("Creating output stack as a virtual stack...") - virtual_bdb_stack_path = "bdb:{}#{}".format( + virtual_star_stack_path = "{}/{}.star".format( args.output_directory, args.sv_vstack_basename ) - cmd_line = "e2bdb.py {} --makevstack={} --list={}".format( - args.input_bdb_stack_path, - virtual_bdb_stack_path, + cmd_line = "sp_star.py {} --makevstack={} --list={}".format( + args.input_star_stack_path, + virtual_star_stack_path, output_particle_id_list_file_path, ) status = sp_utilities.cmdexecute(cmd_line) @@ -3470,7 +3472,7 @@ def get_min_max_filament_coord(self, filament_id, centered): if args.save_vstack: sp_global_def.sxprint( "Save output stack as : {}".format( - virtual_bdb_stack_path + virtual_star_stack_path ) ) @@ -3959,17 +3961,17 @@ def desymmetrize(args): # Check error conditions subcommand_name = "desymmetrize" - args.input_bdb_stack_path = args.input_bdb_stack_path.strip() - if args.input_bdb_stack_path[: len("bdb:")].lower() != "bdb:": - sp_global_def.ERROR( - "Invalid input BDB stack file path %s. The path must start with 'bdb:'. Please check the file path and restart the program." - % (args.input_bdb_stack_path), - where=subcommand_name, - ) # action=1 - fatal error, exit - if not EMAN2db.db_check_dict(args.input_bdb_stack_path, readonly=True): + args.input_star_stack_path = args.input_star_stack_path.strip() + # if args.input_star_stack_path[: len("bdb:")].lower() != "bdb:": + # sp_global_def.ERROR( + # "Invalid input BDB stack file path %s. The path must start with 'bdb:'. Please check the file path and restart the program." + # % (args.input_star_stack_path), + # where=subcommand_name, + # ) # action=1 - fatal error, exit + if not EMAN2db.db_check_dict(args.input_star_stack_path, readonly=True): sp_global_def.ERROR( "Input BDB image stack file %s does not exist. Please check the file path and restart the program." - % (args.input_bdb_stack_path), + % (args.input_star_stack_path), where=subcommand_name, ) # action=1 - fatal error, exit if not os.path.exists(args.input_cluster_path): @@ -4015,7 +4017,7 @@ def desymmetrize(args): # Extract file path from the input BDB dictionary input_bdb_full_path, input_bdb_dictname, input_bdb_keys = EMAN2db.db_parse_path( - args.input_bdb_stack_path + args.input_star_stack_path ) cwd = os.getcwd() if cwd[-1] != cwd[0] or cwd[-1] != cwd[0]: @@ -4031,13 +4033,13 @@ def desymmetrize(args): # # NOTE: EMData.read_images() or get_im() of utilities works as well input_bdb_stack = EMAN2db.db_open_dict( - args.input_bdb_stack_path, ro=True + args.input_star_stack_path, ro=True ) # Read only - n_img_detected = EMAN2_cppwrap.EMUtil.get_image_count(args.input_bdb_stack_path) + n_img_detected = EMAN2_cppwrap.EMUtil.get_image_count(args.input_star_stack_path) sp_global_def.sxprint( "Detected %d particles in symmetrized input BDB stack %s." - % (n_img_detected, args.input_bdb_stack_path) + % (n_img_detected, args.input_star_stack_path) ) sp_global_def.sxprint(" ") @@ -4049,7 +4051,7 @@ def desymmetrize(args): except: sp_global_def.ERROR( "Failed to read image header of particle #%d from %s. Aborting..." - % (0, args.input_bdb_stack_path), + % (0, args.input_star_stack_path), where=subcommand_name, ) # action=1 - fatal error, exit @@ -4059,7 +4061,7 @@ def desymmetrize(args): if "variabilitysymmetry" in img_header: sp_global_def.sxprint( "Detected %s point-group symmetry in specified input BDB stack %s." - % (img_header["variabilitysymmetry"], args.input_bdb_stack_path) + % (img_header["variabilitysymmetry"], args.input_star_stack_path) ) sp_global_def.sxprint(" ") @@ -4121,11 +4123,11 @@ def desymmetrize(args): data_source_path = img_header["data_source"] # sxprint("MRK_DEBUG: data_source_path := ", data_source_path) symmetrization_q_stack_path = ( - "bdb:./Q" + "./Q.star" ) # Unfortunately, sx3dvariability.py --symmetrize uses "/" syntax instead of "#" before bdb dictionary name for this case... (2018/08/08 Toshio) if input_bdb_path != ".": if input_bdb_path != "": - symmetrization_q_stack_path = "bdb:{}#Q".format(input_bdb_path) + symmetrization_q_stack_path = "{}/Q.star".format(input_bdb_path) # else: # else: # # Do nothing @@ -4281,9 +4283,9 @@ def main(): help="ISAC2 Stack Subset: Create virtual subset stack consisting from ISAC2 accounted particles by retrieving particle numbers associated with the ISAC2 or Beautifier class averages. The command also saves a list text file containing the retrieved original image numbers and 2D alignment parameters. In addition, it stores the 2D alignment parameters to stack header.", ) parser_isac_subset.add_argument( - "input_bdb_stack_path", + "input_star_stack_path", type=str, - help="Input BDB image stack: Specify the same BDB image stack used for the associated ISAC2 run. (default required string)", + help="Input Star image stack: Specify the same Star image stack used for the associated ISAC2 run. (default required string)", ) parser_isac_subset.add_argument( "input_run_dir", @@ -4416,7 +4418,7 @@ def main(): help="Restacking: Generate all necessary information to restack the input stack (i.e. particle image ID list and projection parameters list) while applying micrograph selection list. Optinally, the command can directly output the virtual stack. Also, this command can be used to generate all parameters files for reboxing (i.e. original/centered particle coordinates list files, original/centered projection parameters list as well as micrograph selection file). Optionally, user can provided a 3D shift to recenter the projection parameters and so the particle coordinates.", ) parser_restacking.add_argument( - "input_bdb_stack_path", + "input_star_stack_path", type=str, help="Input BDB image stack: Specify the input BDB image stack. (default required string)", ) @@ -4583,7 +4585,7 @@ def main(): ) parser_moon_eliminator.add_argument( "--edge_width", - type=float, + type=int, default=1, help="Soft-edge width [Pixels]: The pixel width of transition area for soft-edged masking.(default 1)", ) @@ -4613,7 +4615,7 @@ def main(): help="UNDER DEVELOPMENT - Desymmetrize particle IDs of a specified cluster sorted by SORT3D. The output will contain the particle IDs of stack before symmetrization.", ) parser_subcmd.add_argument( - "input_bdb_stack_path", + "input_star_stack_path", type=str, help="Input BDB image stack: Specify the symmetrized BDB stack used for the associated SORT3D run. (default required string)", ) diff --git a/sphire/sphire/bin/sp_polishing.py b/sphire/sphire/bin/sp_polishing.py new file mode 100644 index 0000000000..426101a11b --- /dev/null +++ b/sphire/sphire/bin/sp_polishing.py @@ -0,0 +1,710 @@ +#!/usr/bin/env python +## +import tqdm +import os +import subprocess +import sys +import argparse +import time +import json +from glob import glob +import numpy as np +import pandas as pd +import shutil + +try: + from ..libpy import sp_global_def + from ..libpy import sp_utilities +except: + from sphire.libpy import sp_global_def + from sphire.libpy import sp_utilities + +try: + from pyStarDB import sp_pystardb as star +except: + print("Please install pyStarDB package using pip in order to run this tool") + +""" +import mpi +os.unsetenv('OMPI_COMM_WORLD_RANK') +RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ +if RUNNING_UNDER_MPI : + mpi.mpi_init(0, []) + rank = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) + size = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD) +else : + rank =0 + size = 1 + + +env = os.environ +new_env = {k: v for k, v in env.items() if "MPI" not in k} +""" + + +def parse_parameters(args): + parser = argparse.ArgumentParser(args, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser.add_argument( + "post_refiner", + type=str, + help="post refiner directory", + ) + + parser.add_argument( + "corr_mic", + type=str, + help="Motion corr corrected micrographs", + ) + + parser.add_argument( + "Output_folder", + type=str, + help="output_directory", + ) + + parser.add_argument( + "--training_params", + type=str, + help="", + default=None + ) + + parser.add_argument( + "--first_frame", + type=int, + help="", + default=1, + ) + + parser.add_argument( + "--last_frame", + type=int, + help="", + default=-1 + + ) + parser.add_argument( + "--bfac_minfreq", + type=int, + help="", + default=20 + ) + + parser.add_argument( + "--bfac_maxfreq", + type=int, + help="", + default=-1 + ) + + parser.add_argument( + "--min_no_particles", + type=int, + help="", + default=5000 + ) + + parser.add_argument( + "--submission_template", + type=str, + help="", + default=None + ) + + parser.add_argument( + "--submission_command", + type=str, + help="", + default="sbatch" + ) + + parser.add_argument( + "--relion_mpirun_executable", + type=str, + help="", + default="mpirun" + ) + + parser.add_argument( + "--relion_polishing_executable", + type=str, + help="", + default="relion_motion_refine_mpi" + ) + + parser.add_argument( + "--mpi_procs", + type=int, + help="", + default=1 + ) + + parser.add_argument( + "--no_of_threads", + type=int, + help="", + default=1, + ) + + parser.add_argument( + "--mrc_reloc_folder", + type=str, + help="", + default=None + ) + + return parser.parse_args() + + +def get_final_iter(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['best'] + + +def get_bdb_loc(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['stack'] + + +def sanity_function_check(input_folder): + # This is important and will be written as soon as the post refiner part is done. + pass + + +def get_final_iter_files(input_folder): + sanity_function_check(input_folder) + if os.path.isdir(input_folder): + if os.path.exists(os.path.join(input_folder, 'Tracker_final.json')): + tracker_file = os.path.join(input_folder, 'Tracker_final.json') + use_iter = 1 + else: + main_directory = sorted(glob(os.path.join(input_folder, 'main*')))[-1] + tracker_file = glob(os.path.join(main_directory, 'Tracker_*.json'))[0] + use_iter = -1 + + if use_iter == 1: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + else: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + template = '{0}_{1:03d}.{2}' + required_data = [['params', 'txt'], ['chunk_0', 'txt'], ['chunk_1', 'txt']] + required_files = [] + for i, j in required_data: + required_files.append(os.path.join(tracker_file, template.format(i, final_iter, j))) + return required_files, bdbfile + + +def parse_postrefiner(args_post): + parser_post = argparse.ArgumentParser(args_post, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser_post.add_argument( + "command_python", + type=str, + help="", + ) + + parser_post.add_argument( + "--combinemaps", + type=str, + help="", + nargs=2 + ) + + parser_post.add_argument( + "--output_dir", + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--pixel_size", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--mask", + default=None, + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--do_adaptive_mask", + help="", + action='store_true', + ) + + parser_post.add_argument( + "--threshold", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--edge_width", + type=int, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--ndilation", + type=int, + help="", + ) + + parser_post.add_argument( + "--mtf", + type=str, + help="", + default=None, + nargs=1 + ) + + parser_post.add_argument( + "--B_enhance", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--f", + type=float, + help="", + nargs=1 + ) + + return parser_post.parse_args(args_post.split()) + + +def run(args): + options = parse_parameters(args) + + ################################################# + ############Post process call################# + ################################################# + ###### Post process part starts here + if os.path.isdir(options.post_refiner): + with open(os.path.join(options.post_refiner, 'command.txt'), 'r') as commandfile: + read_command_txt = commandfile.read() + + post_refine_options = parse_postrefiner(read_command_txt) + + if post_refine_options.mask != None: + use_mask = post_refine_options.mask[0] + else: + use_mask = os.path.join(options.post_refiner, 'vol_adaptive_mask.hdf') + + try: + shutil.rmtree(os.path.join(str(options.Output_folder), 'PostProcess')) + except FileNotFoundError: + os.makedirs(os.path.join(str(options.Output_folder), 'PostProcess')) + pass + + pp_star_file = star.StarFile(os.path.join(os.path.join(str(options.Output_folder), 'PostProcess'), + 'postprocess.star')) + + half_map1 = post_refine_options.combinemaps[0] + half_map2 = post_refine_options.combinemaps[1] + + if half_map1.endswith('hdf'): + half_1_call = ( + "e2proc3d.py" + + " " + str(half_map1) + + " " + str(half_map1).replace('hdf', 'mrc') + ) + + half_2_call = ( + "e2proc3d.py" + + " " + str(half_map2) + + " " + str(half_map2).replace('hdf', 'mrc') + ) + subprocess.run(args=[half_1_call], shell=True, text=True) + subprocess.run(args=[half_2_call], shell=True, text=True) + half_map1 = half_map1.replace('hdf', 'mrc') + half_map2 = half_map2.replace('hdf', 'mrc') + + if use_mask.endswith('hdf'): + mask_call = ( + "e2proc3d.py" + + " " + str(use_mask) + + " " + str(use_mask).replace('hdf', 'mrc') + ) + subprocess.run(args=[mask_call], shell=True, text=True) + use_mask = use_mask.replace('hdf', 'mrc') + + general_pp = pd.DataFrame([[half_map1, half_map2, use_mask]], + columns=['_rlnUnfilteredMapHalf1', '_rlnUnfilteredMapHalf2', '_rlnMaskName']) + + pp_star_file.update('general', general_pp, False) + + fsc_halves = np.loadtxt(os.path.join(options.post_refiner, 'halves.txt')) + fsc_masked_halves = np.loadtxt(os.path.join(options.post_refiner, 'masked_halves.txt')) + fsc_full = np.loadtxt(os.path.join(options.post_refiner, 'full.txt')) + + spectral_index = fsc_halves[:, 0] + angs_resolution = fsc_halves[:, 1] + resolution = np.divide(1, angs_resolution) + fsc_corrected = fsc_full[:, 2] + fsc_unmasked_maps = fsc_halves[:, 2] + fsc_masked_maps = fsc_masked_halves[:, 2] + + fsc_data_pp = pd.DataFrame(np.array([spectral_index, resolution, angs_resolution, fsc_corrected, + fsc_unmasked_maps, fsc_masked_maps]).swapaxes(0, 1).tolist(), + columns=['_rlnSpectralIndex', '_rlnResolution', '_rlnAngstromResolution', + '_rlnFourierShellCorrelationCorrected', + '_rlnFourierShellCorrelationUnmaskedMaps', + '_rlnFourierShellCorrelationMaskedMaps' + ]) + + for col in fsc_data_pp.columns: + if col == '_rlnSpectralIndex': + fsc_data_pp[col] = fsc_data_pp[col].map(lambda x: int(x)) + else: + fsc_data_pp[col] = fsc_data_pp[col].map(lambda x: '{0:0.4f}'.format(x)) + + pp_star_file.update('fsc', fsc_data_pp, True) + + guiner = np.loadtxt(os.path.join(options.post_refiner, 'guinierlines.txt'), skiprows=1) + if post_refine_options.mtf != None: + resol_sq = guiner[:, 0] + log_amp_orig = guiner[:, 1] + log_amp_weight = guiner[:, 2] + log_amp_sharpened = guiner[:, 3] + + guiner_data_pp = pd.DataFrame( + np.array([resol_sq, log_amp_orig, log_amp_weight, log_amp_sharpened]).swapaxes(0, 1).tolist(), + columns=['_rlnResolutionSquared', '_rlnLogAmplitudesOriginal', '_rlnLogAmplitudesWeighted', + '_rlnLogAmplitudesSharpened' + ]) + else: + resol_sq = guiner[:, 0] + log_amp_orig = guiner[:, 1] + log_amp_weight = guiner[:, 2] + + guiner_data_pp = pd.DataFrame( + np.array([resol_sq, log_amp_orig, log_amp_weight]).swapaxes(0, 1).tolist(), + columns=['_rlnResolutionSquared', '_rlnLogAmplitudesOriginal', '_rlnLogAmplitudesSharpened' + ]) + + pp_star_file.update('guiner', guiner_data_pp, True) + pp_star_file.write_star_file() + + ##### Post Process part ends here + + ################################################# + ############SPHIRE 2 RELION################# + ################################################# + ###### SPHIRE 2 RELION Parts starts here + meridien_folder = post_refine_options.combinemaps[0].split('/vol')[0] + iter_files, bdbfile = get_final_iter_files(meridien_folder) + ##Note sphire2relion requires the 3dparams file and the chunk + + if os.path.isdir(meridien_folder): + sph2rel_call = ( + "sp_sphire2relion.py" + + " " + os.path.join(str(options.Output_folder), "BDB2STAR") + + " " + "--particle_stack=" + str(bdbfile) + + " " + "--params_3d_file=" + str(iter_files[0]) + + " " + "--params_3d_chunk_file_0=" + str(iter_files[1]) + + " " + "--params_3d_chunk_file_1=" + str(iter_files[2]) + ) + + subprocess.run(args=[sph2rel_call], shell=True, text=True) + + #### This wont be necessary in cases where the entire pipeline was run with MotionCorr shifts + bdb_star = star.StarFile(os.path.join(os.path.join(str(options.Output_folder), "BDB2STAR"), + 'sphire2relion.star')) + + if options.mrc_reloc_folder != None: + old_micrograph_name = bdb_star[""]['_rlnMicrographName'] + new_micrograph_name = old_micrograph_name.apply(lambda x: os.path.join(options.mrc_reloc_folder + , os.path.basename(x) + )) + bdb_star[""]['_rlnMicrographName'] = new_micrograph_name + + bdb_star.write_star_file(overwrite=True) + + ####### SPHIRE 2 RELION Parts ends here + + ################################################# + ############Corrected micrograph################# + ################################################# + #######Corrected micrograph part starts here + # This will be later set in case we have motion corr data + time.sleep(5) + + if options.training_params != None: + ### now we need to decide we want to run it on a single PC workstation or on cluster + if options.submission_template != None: + polishing_call = options.relion_polishing_executable \ + + " --i " + os.path.join(str(options.Output_folder), + "BDB2STAR/sphire2relion.star") \ + + " " + "--f " + os.path.join(str(options.Output_folder), + "PostProcess/postprocess.star") \ + + " " + "--corr_mic " + options.corr_mic \ + + " " + "--first_frame " + str(options.first_frame) \ + + " " + "--last_frame " + str(options.last_frame) \ + + " " + "--o " + str(options.Output_folder) \ + + " " + "--params_file " + str(options.training_params) \ + + " " + "--combine_frames" \ + + " " + "--bfac_minfreq " + str(options.bfac_minfreq) \ + + " " + "--bfac_maxfreq " + str(options.bfac_maxfreq) \ + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) \ + + " " + "--j " + str(options.no_of_threads) + + rel2sph_call = "\n\n" + "sp_relion2sphire.py" \ + + " " + os.path.join(str(options.Output_folder), "shiny.star") \ + + " " + "Polish_Stack" \ + + " " + "--relion_project_dir='.'" \ + + " " + "--box_size=-1" + + try: + with open(options.submission_template) as read: + lines = read.readlines() + except Exception as e: + sp_global_def.ERROR(str(e) + '\nCannot open mpi_submission template!', action=1) + + cmd_lines = [] + for idx, entry in enumerate(lines): + if "XXX_SXCMD_LINE_XXX" in entry and "mpirun" in entry: + cmd_lines.append(idx) + + if not cmd_lines: + sp_global_def.sxprint("Could not find a suitable command line for exchange.") + sp_global_def.sxprint("The line should contain XXX_SXCMD_LINE_XXX.") + sys.exit(1) + + line = (lines[cmd_lines[-1]].replace("XXX_SXCMD_LINE_XXX", polishing_call + rel2sph_call)) + + mod_sub_script = "".join(lines).replace("XXX_SXMPI_NPROC_XXX", str(options.mpi_procs) + ).replace("XXX_SXMPI_JOB_NAME_XXX", "sp_polishing" + ).replace(lines[cmd_lines[-1]], line + ).replace("mpirun", + options.relion_mpirun_executable) + + out_submission = "{0}/polishing_submission_script.sh".format(str(options.Output_folder)) + with open(out_submission, "w") as w: + w.write("".join(mod_sub_script)) + + sp_global_def.sxprint( + subprocess.check_output( + options.submission_command.split() + [out_submission] + ) + ) + else: + # if we want to run it on a workstation + import mpi + os.unsetenv('OMPI_COMM_WORLD_RANK') + RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + if RUNNING_UNDER_MPI: + mpi.mpi_init(0, []) + rank = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) + size = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD) + else: + rank = 0 + size = 1 + + env = os.environ + new_env = {k: v for k, v in env.items() if "MPI" not in k} + + polishing_call = ( + "mpirun" + + " " + "-np" + + " " + str(options.mpi_procs) + + " " + options.relion_polishing_executable + + " --i " + + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--f " + os.path.join(str(options.Output_folder), "PostProcess/postprocess.star") + + " " + "--corr_mic " + options.corr_mic + + " " + "--first_frame " + str(options.first_frame) + + " " + "--last_frame " + str(options.last_frame) + + " " + "--o " + str(options.Output_folder) + + " " + "--params_file " + str(options.training_params) + + " " + "--combine_frames" + + " " + "--bfac_minfreq " + str(options.bfac_minfreq) + + " " + "--bfac_maxfreq " + str(options.bfac_maxfreq) + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) + + " " + "--j " + str(options.no_of_threads) + ) + rel2sph_call = ( + "sp_relion2sphire.py" + + " " + os.path.join(str(options.Output_folder), "shiny.star") + + " " + "Polish_Stack" + + " " + "--relion_project_dir='.'" + + " " + "--box_size=-1" + ) + + print("Polishing command is called", polishing_call) + subprocess.run(args=[polishing_call], shell=True, text=True, env=new_env) + subprocess.run(args=[rel2sph_call], shell=True, text=True) + + else: + print("Parameter file not provided, hence training is performed") + polishing_call = ( + options.relion_polishing_executable + + " --i " + + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--f " + os.path.join(str(options.Output_folder), "PostProcess/postprocess.star") + + " " + "--corr_mic " + options.corr_mic + + " " + "--first_frame " + str(options.first_frame) + + " " + "--last_frame " + str(options.last_frame) + + " " + "--o " + str(options.Output_folder) + + " " + "--min_p " + str(options.min_no_particles) + + " " + "--eval_frac " + str(0.5) + + " " + "--align_frac " + str(0.5) + + " " + "--angpix_ref " + str(post_refine_options.pixel_size[0]) + + " " + "--params3" + + " " + "--j " + str(options.no_of_threads) + + " " + "--pipeline_control " + str(options.Output_folder) + ) + print("Polishing command is ", polishing_call) + subprocess.run(args=[polishing_call], shell=True, text=True) + + +## +def main(): + try: + sp_global_def.print_timestamp("Start") + run(sys.argv[1:]) + finally: + sp_global_def.print_timestamp("Finish") + + +if __name__ == "__main__": + main() + +""" +corr_sums_log = os.path.join(main_location, 'CorrectedSums/corrsum_dw_log/') +corr_sums_mrc = os.path.join(main_location, 'CorrectedSums/corrsum_dw/') + +corr_sum_star = os.path.join(main_location, options.corr_mic) +logfiles = glob('{}*.star'.format(os.path.join(os.path.dirname(corr_sum_star), 'Movies/'))) +if logfiles == []: + logfiles = glob('{}*.log'.format(corr_sums_log)) + mrcfiles = glob('{}*.mrc'.format(corr_sums_mrc)) +else: + mrcfiles = glob('{}*.mrc'.format(os.path.join(os.path.dirname(corr_sum_star), 'Movies/'))) + +if logfiles[0].endswith('.star'): + final_motion_path = corr_sum_star +else: + ### there is no guarantee that conversion from unblur data will work so better to use MotionCorr + final_motion_path = os.path.join(os.path.join(os.getcwd(), 'MotionCorr/corrected_micrographs.star')) + # try: + # shutil.rmtree(os.path.join(os.getcwd(), 'MotionCorr')) + # except FileNotFoundError: + # os.makedirs(os.path.join(os.getcwd(), 'MotionCorr')) + # pass + + early_data = [] + late_data = [] + total_data = [] + + for test_logfile in logfiles: + + new_log_name = os.path.basename(test_logfile).split('.log')[0] + pp_star_motion = star.StarFile(os.path.join(os.path.join(os.getcwd(), 'MotionCorr'), + '{}.star'.format(new_log_name))) + + with open(test_logfile, 'r') as logfile: + all_lines = logfile.readlines() + shifts = [] + for line in all_lines: + if line[:5] == 'image': + shifts.append([float(item) for item in line.split('=')[1:][0].split(',')]) + elif line[:20] == 'Input stack filename': + motion_Input_stack = line.split(':')[1].replace(' ', '').replace('\n', '') + motion_Input_stack = os.path.join(os.getcwd(), motion_Input_stack) + elif line[:14] == 'Output binning': + motion_output_bin = line.split(':')[1].replace(' ', '').replace('\n', '') + elif line[:5] == 'Pixel': + motion_pixel_size = line.split(':')[1].replace(' ', '').replace('\n', '') + elif line[:8] == 'Exposure': + motion_exposure = line.split(':')[1].replace(' ', '').replace('\n', '') + elif line[:12] == 'Pre-exposure': + motion_pre_exposure = line.split(':')[1].replace(' ', '').replace('\n', '') + elif line[:12] == 'Acceleration': + motion_voltage = line.split(':')[1].replace(' ', '').replace('\n', '') + elif line[:5] == 'First': + motion_first_frame = line.split(':')[1].replace(' ', '').replace('\n', '') + + stack_metadata = EMAN2db.db_get_image_info(motion_Input_stack) + xsize = stack_metadata[1][0] + ysize = stack_metadata[1][1] + zsize = stack_metadata[1][2] + motion_meta_data_pp = pd.DataFrame([[xsize, ysize, zsize, motion_Input_stack, motion_output_bin, + motion_pixel_size, motion_exposure, + motion_pre_exposure, motion_voltage, motion_first_frame, 0]], + columns=['_rlnImageSizeX', '_rlnImageSizeY', '_rlnImageSizeZ', + '_rlnMicrographMovieName', '_rlnMicrographBinning', + '_rlnMicrographOriginalPixelSize', '_rlnMicrographDoseRate', + '_rlnMicrographPreExposure', '_rlnVoltage', + '_rlnMicrographStartFrame', '_rlnMotionModelVersion']) + + pp_star_motion.update('general', motion_meta_data_pp, False) + + motion_data_pp = pd.DataFrame() + + motion_data_pp['_rlnMicrographFrameNumber'] = np.arange(1, len(shifts) + 1) + motion_data_pp['_rlnMicrographShiftX'] = np.array(shifts)[:, 0] - np.array(shifts)[0, 0] + motion_data_pp['_rlnMicrographShiftY'] = np.array(shifts)[:, 1] - np.array(shifts)[0, 1] + + pp_star_motion.update('global_shift', motion_data_pp, True) + pp_star_motion.write_star_file() + + ### because dose_rate = 2.5 ,.... number of frames for early = dose_rate * n < 4 where n is the number of frames + + cutoff_frame = (4 - float(motion_pre_exposure)) / float(motion_exposure) + cutoff = 0 + for i in range(2, len(shifts)): + if i <= int(cutoff_frame): + cuttoff = i + else: + pass + + total_diff = np.array(shifts)[1:] - np.array(shifts)[:-1] + total = np.sum(np.sqrt(np.inner(total_diff, total_diff).diagonal())) + try: + if cutoff == 0: + early = 0 + else: + early = np.sum(np.sqrt(np.inner(total_diff[:cutoff], total_diff[:cutoff]).diagonal())) + except ValueError: + if cutoff == 0: + early = 0 + else: + early = np.sum(np.sqrt(np.inner(total_diff[:cutoff], total_diff[:cutoff]))) + + late = total - early + early_data.append(early) + late_data.append(late) + total_data.append(total) + + newlogfiles = glob('{}*.star'.format(os.path.join(os.getcwd(), 'MotionCorr/'))) + + corr_micro_star = star.StarFile(os.path.join(os.path.join(os.getcwd(), 'MotionCorr'), + 'corrected_micrographs.star')) + micrograph_files = pd.DataFrame(np.array([mrcfiles, newlogfiles, total_data, early_data, + late_data]).swapaxes(0, 1).tolist(), + columns=['_rlnMicrographName', '_rlnMicrographMetadata', + '_rlnAccumMotionTotal', '_rlnAccumMotionEarly', + '_rlnAccumMotionLate']) + corr_micro_star.update('', micrograph_files, True) + corr_micro_star.write_star_file() +""" diff --git a/sphire/sphire/bin/sp_process.py b/sphire/sphire/bin/sp_process.py index 3b3f3da5b4..ce95d2718e 100755 --- a/sphire/sphire/bin/sp_process.py +++ b/sphire/sphire/bin/sp_process.py @@ -49,14 +49,14 @@ import optparse import os import random -from ..libpy import sp_filter -from ..libpy import sp_fundamentals -from ..libpy import sp_global_def -from ..libpy import sp_logger -from ..libpy import sp_morphology -from ..libpy import sp_projection -from ..libpy import sp_statistics -from ..libpy import sp_utilities +from sphire.libpy import sp_filter +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_logger +from sphire.libpy import sp_morphology +from sphire.libpy import sp_projection +from sphire.libpy import sp_statistics +from sphire.libpy import sp_utilities import sys import time import subprocess @@ -1034,9 +1034,9 @@ def run(): root, name = os.path.split(ctfs[kk][-1]) ctfs[kk][-1] = name[:-4] - if options.input[:4] != "bdb:": - sp_global_def.ERROR("Sorry, only bdb files implemented") - return + # if options.input[:4] != "bdb:": + # sp_global_def.ERROR("Sorry, only bdb files implemented") + # return d = options.input[4:] # try: str = d.index('*') diff --git a/sphire/sphire/bin/sp_relion_3dclassifi.py b/sphire/sphire/bin/sp_relion_3dclassifi.py new file mode 100644 index 0000000000..1242dfacd0 --- /dev/null +++ b/sphire/sphire/bin/sp_relion_3dclassifi.py @@ -0,0 +1,892 @@ +#!/usr/bin/env python +## +import tqdm +import os +import subprocess +import sys +import argparse +import time +import json +from glob import glob +import numpy as np +import pandas as pd +import shutil + +try: + from ..libpy import sp_global_def + from ..libpy import sp_utilities +except: + from sphire.libpy import sp_global_def + from sphire.libpy import sp_utilities + +try: + from pyStarDB import sp_pystardb as star +except : + print("Please install pyStarDB package to run this") + +def parse_parameters(args): + parser = argparse.ArgumentParser(args, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser.add_argument( + "post_refiner", + type=str, + help="post refiner directory", + ) + + parser.add_argument( + "Output_folder", + type=str, + help="output_directory", + ) + + parser.add_argument( + "reference_map", + type=str, + help="reference map", + ) + + parser.add_argument( + "--reference_mask", + type=str, + help="reference mask, optional", + default = None + ) + + parser.add_argument( + "--abs_greyscale_map", + action="store_true", + help="Ref map is on absolute greyscale", + default = False + ) + + parser.add_argument( + "--ini_high", + type=float, + help="initial low pass filter in angstorms", + default = 60 + ) + + parser.add_argument( + "--sym", + type=str, + help="symmetry use for classification", + default = "C1" + ) + + parser.add_argument( + "--do_ctf", + action="store_true", + help="Do CTF correction", + default = True + ) + + parser.add_argument( + "--ctf_corr_ref", + action="store_true", + help="Has reference been CTF corrected", + default = False, + ) + + parser.add_argument( + "--ctf_ignore_peak", + action="store_true", + help="Ignore CTFs unit first peak", + default = False, + ) + + parser.add_argument( + "--no_of_class", + type=int, + help="Number of classes", + default = 1 + ) + + parser.add_argument( + "--tau_val", + type=float, + help="Regularisation parameter T", + default = 4 + ) + + parser.add_argument( + "--no_of_iter", + type=int, + help="Number of iterations", + default = 25 + ) + + parser.add_argument( + "--use_fast_sets", + action="store_true", + help="Use fast subsets (for large datasets)", + default = False, + ) + + parser.add_argument( + "--diam_mas", + type=int, + help="Maske diameter in angstorm", + default = 200 + ) + + parser.add_argument( + "--zeros_mas", + action="store_true", + help="Mask individual particles with zeros", + default = True, + ) + + parser.add_argument( + "--limit_resol_estep", + type=int, + help="Limit resolution E-step to (A)", + default = -1 + ) + + parser.add_argument( + "--skip_img_align", + action="store_true", + help="Perform image alignment or not", + ) + + parser.add_argument( + "--heal_pix_order", + type=float, + help="Angular sampling interval", + default = 7.5 + ) + + parser.add_argument( + "--off_range", + type=int, + help="Offset search range (pix)", + default = 5 + ) + + parser.add_argument( + "--off_step", + type=int, + help="Offset search step (pix)", + default = 1 + ) + + parser.add_argument( + "--ang_search", + action="store_true", + help="Perform local angular searches", + default = False, + ) + + parser.add_argument( + "--ang_search_range", + type=int, + help="Local angular search", + default = 5 + ) + + parser.add_argument( + "--ang_search_relax_sym", + type=str, + help="Relax Symmetry", + default = None + ) + + parser.add_argument( + "-coarse_sampling", + action="store_true", + help="Allow coarser sampling", + default = False, + ) + + parser.add_argument( + "-para_io", + action="store_true", + help="Use parallel disc I/O", + default = True, + ) + + parser.add_argument( + "--no_of_pool_part", + type=int, + help="Number of pooled particles", + default = 3 + ) + + parser.add_argument( + "--skip_pad", + action="store_true", + help="Skip padding", + default=False, + ) + + parser.add_argument( + "--skip_grid", + action="store_true", + help="Skip padding", + default=True, + ) + + parser.add_argument( + "--pre_read_img", + action="store_true", + help="Pre-read all particles into RAM", + default=False, + ) + + parser.add_argument( + "--scratch_dir", + type=str, + help="Copy particles to search directory", + default = None + ) + + parser.add_argument( + "--combine_iter_disc", + action="store_true", + help="Combine iterations through disc", + default=False, + ) + + parser.add_argument( + "--use_gpu", + action="store_true", + help="Use GPU acceleration", + default=False, + ) + + parser.add_argument( + "--which_gpu", + type=str, + help="Which GPU to use", + default = None + ) + + parser.add_argument( + "--submission_template", + type = str, + help ="", + default = None + ) + + parser.add_argument( + "--submission_command", + type=str, + help="", + default="sbatch" + ) + + parser.add_argument( + "--relion_mpirun_executable", + type=str, + help="", + default="mpirun" + ) + + parser.add_argument( + "--relion_3dclassification_executable", + type=str, + help="", + default="relion_refine_mpi" + ) + + parser.add_argument( + "--mpi_procs", + type= int, + help ="", + default = 1 + ) + + parser.add_argument( + "--no_of_threads", + type=int, + help="", + default= 1, + ) + + parser.add_argument( + "--mrc_reloc_folder", + type=str, + help="mrc relocation folder directory", + default = None + ) + + ###### Here the helical part starts + # parser.add_argument( + # "--helical_recons", + # action="store_true", + # help="Do helical reconstruction", + # default = False + # ) + + + # parser.add_argument( + # "--inner_diam", + # type=float, + # help="Helical Tube inner diameter", + # default= -1, + # ) + + + # parser.add_argument( + # "--outer_diam", + # type=float, + # help="Helical Tube outer diameter", + # default= -1, + # ) + + # parser.add_argument( + # "--sig_tilt", + # type=float, + # help="Angular search range for tilt (deg)", + # default= 15, + # ) + + # parser.add_argument( + # "--sig_psi", + # type=float, + # help="Angular search range for psi (deg)", + # default= 10, + # ) + + # parser.add_argument( + # "--sig_rot", + # type=float, + # help="Angular search range for rot (deg)", + # default= -1, + # ) + + # parser.add_argument( + # "--sigma_dist", + # type=float, + # help="Range factor of local average", + # default= 1.5, + # ) + # + # parser.add_argument( + # "--keep_tilt_fix", + # action="store_true", + # help="Keep tilt-prior fixed", + # default= True, + # ) + + # parser.add_argument( + # "--apply_helical_sym", + # action="store_true", + # help="Apply helical symmetry", + # default= False, + # ) + # + # parser.add_argument( + # "--unique_asym_unit", + # type=int, + # help="Number of unique asymmetrical units", + # default= 1, + # ) + # + # parser.add_argument( + # "--initial_twist", + # type=float, + # help="Initial twise (deg)", + # default= 0, + # ) + # + # parser.add_argument( + # "--initial_rise", + # type=float, + # help="Initial rise (A)", + # default= 0, + # ) + + # parser.add_argument( + # "--z_percent", + # type=int, + # help="Central Z length (%)", + # default= 30, + # ) + # + # parser.add_argument( + # "--do_local_search", + # action="store_true", + # help="Do local searches of symmetry", + # default= False, + # ) + # + # parser.add_argument( + # "--twist_min", + # type=float, + # help="Twist search min (deg)", + # default= 0, + # ) + # + # parser.add_argument( + # "--twist_max", + # type=float, + # help="Twist search max (deg)", + # default= 0, + # ) + # + # parser.add_argument( + # "--twist_inistep", + # type=float, + # help="Twist search step (deg)", + # default= 0, + # ) + # + # parser.add_argument( + # "--rise_min", + # type=float, + # help="Rise search min (A)", + # default= 0, + # ) + # + # parser.add_argument( + # "--rise_max", + # type=float, + # help="Rise search max (A)", + # default= 0, + # ) + # + # parser.add_argument( + # "--rise_inistep", + # type=float, + # help="Rise search max (A)", + # default= 0, + # ) + + return parser.parse_args() + + +def get_final_iter(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['best'] + + +def get_bdb_loc(tracker_file): + with open(tracker_file) as jsonfile: + Tracker = json.load(jsonfile) + return Tracker['constants']['stack'] + + +def sanity_function_check(input_folder): + # This is important and will be written as soon as the post refiner part is done. + pass + + +def get_final_iter_files(input_folder): + sanity_function_check(input_folder) + if os.path.isdir(input_folder): + if os.path.exists(os.path.join(input_folder, 'Tracker_final.json')): + tracker_file = os.path.join(input_folder, 'Tracker_final.json') + use_iter = 1 + else: + main_directory = sorted(glob(os.path.join(input_folder, 'main*')))[-1] + tracker_file = glob(os.path.join(main_directory, 'Tracker_*.json'))[0] + use_iter = -1 + + if use_iter == 1: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + else: + final_iter = get_final_iter(str(tracker_file)) + bdbfile = get_bdb_loc(tracker_file) + tracker_file = os.path.join(str(input_folder), 'main{:03d}'.format(final_iter)) + + template = '{0}_{1:03d}.{2}' + required_data = [['params', 'txt'], ['chunk_0', 'txt'], ['chunk_1', 'txt']] + required_files = [] + for i, j in required_data: + required_files.append(os.path.join(tracker_file, template.format(i, final_iter, j))) + return required_files, bdbfile + + +def parse_postrefiner(args_post): + parser_post = argparse.ArgumentParser(args_post, formatter_class=argparse.ArgumentDefaultsHelpFormatter) + + parser_post.add_argument( + "command_python", + type=str, + help="", + ) + + parser_post.add_argument( + "--combinemaps", + type=str, + help="", + nargs=2 + ) + + parser_post.add_argument( + "--output_dir", + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--pixel_size", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--mask", + default=None, + type=str, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--do_adaptive_mask", + help="", + action='store_true', + ) + + parser_post.add_argument( + "--threshold", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--edge_width", + type=int, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--ndilation", + type=int, + help="", + ) + + parser_post.add_argument( + "--mtf", + type=str, + help="", + default = None + ) + + parser_post.add_argument( + "--B_enhance", + type=float, + help="", + nargs=1 + ) + + parser_post.add_argument( + "--f", + type=float, + help="", + nargs=1 + ) + + return parser_post.parse_args(args_post.split()) + + +def run(args): + options = parse_parameters(args) + + if os.path.isdir(options.post_refiner): + with open(os.path.join(options.post_refiner, 'command.txt'), 'r') as commandfile: + read_command_txt = commandfile.read() + + post_refine_options = parse_postrefiner(read_command_txt) + + ###### SPHIRE 2 RELION Parts starts here + meridien_folder = post_refine_options.combinemaps[0].split('/vol')[0] + iter_files, bdbfile = get_final_iter_files(meridien_folder) + ##Note sphire2relion requires the 3dparams file and the chunk + + if os.path.isdir(meridien_folder): + sph2rel_call = ( + "sp_sphire2relion.py" + + " " + os.path.join(str(options.Output_folder), "BDB2STAR") + + " " + "--particle_stack=" + str(bdbfile) + + " " + "--params_3d_file=" + str(iter_files[0]) + + " " + "--params_3d_chunk_file_0=" + str(iter_files[1]) + + " " + "--params_3d_chunk_file_1=" + str(iter_files[2]) + ) + + subprocess.run(args=[sph2rel_call], shell=True, text=True) + + if options.mrc_reloc_folder != None: + bdb_star = star.StarFile( + os.path.join(os.path.join(str(options.Output_folder), "BDB2STAR"), 'sphire2relion.star')) + old_micrograph_name = bdb_star[""]['_rlnMicrographName'] + new_micrograph_name = old_micrograph_name.apply(lambda x: os.path.join(options.mrc_reloc_folder + , os.path.basename(x) + )) + bdb_star[""]['_rlnMicrographName'] = new_micrograph_name + bdb_star.write_star_file(overwrite=True) + + + total_str = "" + if options.reference_mask != None : + total_str += " " + "--solvent_mask" + " " + str(options.reference_mask) + else: + pass + + ##Now reference part starts + if options.ini_high: + total_str += " " + "--ini_high" + " " + str(options.ini_high) + else: + pass + if options.sym : + total_str += " " + "--sym" + " " + str(options.sym) + else: + pass + if options.abs_greyscale_map : + pass + else: + total_str += " " + "--firstiter_cc" + + #Now sCTF part starts + if options.do_ctf: + total_str += " " + "--ctf" + if options.ctf_corr_ref: + total_str += " " + "--ctf_corrected_ref" + if options.ctf_ignore_peak : + total_str += " " + "--ctf_intact_first_peak" + else: + pass + + ### Now Optimization part starts + if options.no_of_class: + total_str += " " + "--K" + " " + str(options.no_of_class) + else: + pass + if options.tau_val: + total_str += " " + "--tau2_fudge" + " " + str(options.tau_val) + else: + pass + if options.no_of_iter: + total_str += " " + "--iter" + " " + str(options.no_of_iter) + else: + pass + if options.use_fast_sets: + total_str += " " + "--fast_subsets" + else: + pass + if options.diam_mas: + total_str += " " + "--particle_diameter" + " " + str(options.diam_mas) + else: + pass + if options.zeros_mas: + total_str += " " + "--zero_mask" + else: + pass + if options.limit_resol_estep: + total_str += " " + "--strict_highres_exp" + " " + str(options.limit_resol_estep) + else: + pass + + ### Now Sampling part starts + if options.skip_img_align : + total_str += " " + "--skip_align" + " " + str(options.skip_img_align) + else: + if options.heal_pix_order : + sample_value = 2 + if options.heal_pix_order == 0.1 : + sample_value = 8 + elif options.heal_pix_order == 0.2 : + sample_value = 7 + elif options.heal_pix_order == 0.5 : + sample_value = 6 + elif options.heal_pix_order == 0.9 : + sample_value = 5 + elif options.heal_pix_order == 1.8 : + sample_value = 4 + elif options.heal_pix_order == 3.7 : + sample_value = 3 + elif options.heal_pix_order == 7.5 : + sample_value = 2 + elif options.heal_pix_order == 15 : + sample_value = 1 + elif options.heal_pix_order == 30 : + sample_value = 0 + else : + print("Please specify the right value from the drop down menu, the value can be either \ + 0.1, 0.2, 0.5, 0.9, 1.8, 3.7, 7.5, 15, 30") + total_str += " " + "--healpix_order" + " " + str(sample_value) + else: + pass + if options.off_range : + total_str += " " + "--offset_range" + " " + str(options.off_range) + else: + pass + if options.off_step : + total_str += " " + "--offset_step" + " " + str(options.off_step*2) + else: + pass + if options.ang_search : + total_str += " " + "--sigma_ang" + " " + str(options.ang_search_range*0.3333) + if ang_search_relax_sym != None: + total_str += " " + "--relax_sym" + " " + str(ang_search_relax_sym) + else : + pass + else: + pass + if options.coarse_sampling : + total_str += " " + "--allow_coarser_sampling" + else: + pass + + ### Now Compute part starts + if options.para_io : + pass + else: + total_str += " " + "--no_parallel_disc_io" + if options.no_of_pool_part : + total_str += " " + "--pool" + " " + str(options.no_of_pool_part) + else: + pass + if options.skip_pad : + total_str += " " + "--pad" + " " + str(1) + else: + total_str += " " + "--pad" + " " + str(2) + if options.skip_grid : + total_str += " " + "--skip_gridding" + else: + pass + if options.pre_read_img : + total_str += " " + "--preread_images" + else: + pass + if options.scratch_dir != None: + total_str += " " + "--scratch_dir" + " " + str(options.scratch_dir) + else: + pass + if options.combine_iter_disc : + pass + else: + total_str += " " + "--dont_combine_weights_via_disc" + + if options.use_gpu : + if options.which_gpu !=None : + total_str += " " + "--gpu" + " " + str(options.which_gpu) + else: + pass + + ### Adding unknown flags which i can still not debugg + total_str += " " +"--flatten_solvent --oversampling 1 --norm --scale" + + + print("flags for the all commands is", total_str) + print("pixel size obtained is" , post_refine_options.pixel_size[0]) + time.sleep(5) + + ### now we need to decide we want to run it on a single PC workstation or on cluster + if options.submission_template != None: + classification_call = options.relion_3dclassification_executable \ + + " " + "--o " + str(options.Output_folder) \ + + " --i " + os.path.join(options.Output_folder, "BDB2STAR/sphire2relion.star") \ + + " " + "--ref " + str(options.reference_map) \ + + " " + total_str \ + + " " + "--j " + str(options.no_of_threads) + + try: + with open(options.submission_template) as read: + lines = read.readlines() + except Exception as e: + sp_global_def.ERROR(str(e) + '\nCannot open mpi_submission template!', action=1) + + cmd_lines = [] + for idx, entry in enumerate(lines): + if "XXX_SXCMD_LINE_XXX" in entry and "mpirun" in entry: + cmd_lines.append(idx) + + if not cmd_lines: + sp_global_def.sxprint("Could not find a suitable command line for exchange.") + sp_global_def.sxprint("The line should contain XXX_SXCMD_LINE_XXX.") + sys.exit(1) + + line = (lines[cmd_lines[-1]].replace("XXX_SXCMD_LINE_XXX", classification_call)) + + mod_sub_script = "".join(lines).replace("XXX_SXMPI_NPROC_XXX", str(options.mpi_procs) + ).replace("XXX_SXMPI_JOB_NAME_XXX", "sp_relion_3dclassifi" + ).replace(lines[cmd_lines[-1]], line + ).replace("mpirun", + options.relion_mpirun_executable) + + out_submission = "{0}/classification3d_submission_script.sh".format(str(options.Output_folder)) + with open(out_submission, "w") as w: + w.write("".join(mod_sub_script)) + + sp_global_def.sxprint( + subprocess.check_output( + options.submission_command.split() + [out_submission] + ) + ) + + else: + if options.mpi_procs > 1: + # if we want to run it on a workstation + import mpi + os.unsetenv('OMPI_COMM_WORLD_RANK') + RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + if RUNNING_UNDER_MPI: + mpi.mpi_init(0, []) + rank = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) + size = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD) + else: + rank = 0 + size = 1 + + env = os.environ + new_env = {k: v for k, v in env.items() if "MPI" not in k} + + classification_call = ( + "mpirun" + + " " + "-np" + + " " + str(options.mpi_procs) + + " " + options.relion_3dclassification_executable + + " " + "--o " + str(options.Output_folder) + + " --i " + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--ref " + str(options.reference_map) + + " " + total_str + + " " + "--j " + str(options.no_of_threads) + ) + # rel2sph_call = ( + # "sp_relion2sphire.py" + # + " " + os.path.join(str(options.Output_folder), "shiny.star") + # + " " + "Polish_Stack" + # + " " + "--relion_project_dir='.'" + # + " " + "--box_size=-1" + # ) + + print("3d classification with mpi command is called", classification_call) + subprocess.run(args=[classification_call], shell=True, text=True, env=new_env) + # subprocess.run(args=[rel2sph_call], shell=True, text=True) + else: + classification_call = ( + options.relion_3dclassification_executable + + " " + "--o " + str(options.Output_folder) + + " --i " + os.path.join(str(options.Output_folder), "BDB2STAR/sphire2relion.star") + + " " + "--ref " + str(options.reference_map) + + " " + total_str + + " " + "--j " + str(options.no_of_threads) + ) + print("3dclasification without mpi command is called", classification_call) + subprocess.run(args=[classification_call], shell=True, text=True) + + +### + +def main(): + + try: + sp_global_def.print_timestamp("Start") + run(sys.argv[1:]) + finally: + sp_global_def.print_timestamp("Finish") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/sphire/sphire/bin/sp_rviper.py b/sphire/sphire/bin/sp_rviper.py index 55a96fead3..4d11e2e54a 100755 --- a/sphire/sphire/bin/sp_rviper.py +++ b/sphire/sphire/bin/sp_rviper.py @@ -51,14 +51,14 @@ import random import shutil import six -from ..libpy import sp_applications -from ..libpy import sp_fundamentals -from ..libpy import sp_global_def -from ..libpy import sp_logger -from ..libpy import sp_multi_shc -from ..libpy import sp_statistics -from ..libpy import sp_user_functions -from ..libpy import sp_utilities +from sphire.libpy import sp_applications +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_logger +from sphire.libpy import sp_multi_shc +from sphire.libpy import sp_statistics +from sphire.libpy import sp_user_functions +from sphire.libpy import sp_utilities import string import sys import time diff --git a/sphire/sphire/bin/sp_sort3d_depth.py b/sphire/sphire/bin/sp_sort3d_depth.py index 70eadfa6e0..4b4cda2f08 100755 --- a/sphire/sphire/bin/sp_sort3d_depth.py +++ b/sphire/sphire/bin/sp_sort3d_depth.py @@ -69,6 +69,8 @@ import time from builtins import range +from scipy import stats + """ There are two ways to run the program: @@ -1646,49 +1648,49 @@ def do_one_way_anova_scipy( pass if K == 2: - res = scipy.stats.f_oneway(x0, x1) + res = stats.f_oneway(x0, x1) elif K == 3: - res = scipy.stats.f_oneway(x0, x1, x2) + res = stats.f_oneway(x0, x1, x2) elif K == 4: - res = scipy.stats.f_oneway(x0, x1, x2, x3) + res = stats.f_oneway(x0, x1, x2, x3) elif K == 5: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4) + res = stats.f_oneway(x0, x1, x2, x3, x4) elif K == 6: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5) elif K == 7: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6) elif K == 8: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7) elif K == 9: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8) elif K == 10: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9) elif K == 11: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) elif K == 12: - res = scipy.stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) + res = stats.f_oneway(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) elif K == 13: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 ) elif K == 14: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13 ) elif K == 15: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14 ) elif K == 16: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 ) elif K == 17: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16 ) elif K == 18: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1709,7 +1711,7 @@ def do_one_way_anova_scipy( x17, ) elif K == 19: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1731,7 +1733,7 @@ def do_one_way_anova_scipy( x18, ) elif K == 20: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1754,7 +1756,7 @@ def do_one_way_anova_scipy( x19, ) elif K == 21: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1778,7 +1780,7 @@ def do_one_way_anova_scipy( x20, ) elif K == 22: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1803,7 +1805,7 @@ def do_one_way_anova_scipy( x21, ) elif K == 23: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1829,7 +1831,7 @@ def do_one_way_anova_scipy( x22, ) elif K == 24: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1856,7 +1858,7 @@ def do_one_way_anova_scipy( x23, ) elif K == 25: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1884,7 +1886,7 @@ def do_one_way_anova_scipy( x24, ) elif K == 26: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1913,7 +1915,7 @@ def do_one_way_anova_scipy( x25, ) elif K == 27: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1943,7 +1945,7 @@ def do_one_way_anova_scipy( x26, ) elif K == 28: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -1974,7 +1976,7 @@ def do_one_way_anova_scipy( x27, ) elif K == 29: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -2006,7 +2008,7 @@ def do_one_way_anova_scipy( x28, ) elif K == 30: - res = scipy.stats.f_oneway( + res = stats.f_oneway( x0, x1, x2, @@ -2114,7 +2116,7 @@ def do_one_way_anova_scipy( ) for ires in range(K - 1): for jres in range(ires + 1, K): - cres = scipy.stats.f_oneway(replicas[ires], replicas[jres]) + cres = stats.f_oneway(replicas[ires], replicas[jres]) log_main.add( "{:5} {:^3d} {:^3d} {:12.4f} {:12.4f} {:12.3f} {:12.4f} ".format( "ANOVA", diff --git a/sphire/sphire/bin/sp_star.py b/sphire/sphire/bin/sp_star.py new file mode 100644 index 0000000000..2ef8b0daae --- /dev/null +++ b/sphire/sphire/bin/sp_star.py @@ -0,0 +1,172 @@ +#!/usr/bin/env python + +import glob +import argparse +from sphire.libpy import sp_global_def +import os +import sys +import numpy as np +import time +import mpi + +from sphire.libpy import sp_utilities +try: + from pyStarDB import sp_pystardb as star +except: + print("sp_star module requires a pyStarDB package") + +def run(): + program_name = os.path.basename(sys.argv[0]) + parser = argparse.ArgumentParser(description="Similar to e2bdb.py for creating star file stacks") + parser.add_argument( + "--version", action="version", version=sp_global_def.SPARXVERSION + ) + + parser.add_argument( + "root_dir", + type=str, + nargs='+', + help="The root directory where all the data is present" + ) + + parser.add_argument( + "--makevstack", + type=str, + help="Creates a 'virtual' star stack with its own metadata, " + "but the data taken from the (filtered) list of stacks" + ) + + parser.add_argument( + "--list", + type=str, + help="Specify the name of a file with a list of images to use in creation" + " of virtual stacks. Please see source for details.", + ) + + parser.add_argument( + "--exlist", + type=str, + help="Specify the name of a file with a list of images to not use in creation" + " of virtual stacks. Please see source for details.", + ) + + parser.add_argument( + "--step", + type=str, + default="0,1", + help="Specify ,[,]. Processes only a subset of the input data." + " For example, 0,2 would process only the even numbered particles") + + options = parser.parse_args() + args = sys.argv[1:] + + + # ==================================================================================== + # Prepare processing + # ==================================================================================== + # ------------------------------------------------------------------------------------ + # Set up MPI related variables + # ------------------------------------------------------------------------------------ + # Detect if program is running under MPI + RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + + main_mpi_proc = 0 + if RUNNING_UNDER_MPI: + my_mpi_proc_id = mpi.mpi_comm_rank(mpi.MPI_COMM_WORLD) + n_mpi_procs = mpi.mpi_comm_size(mpi.MPI_COMM_WORLD) + else: + my_mpi_proc_id = 0 + n_mpi_procs = 1 + + # ------------------------------------------------------------------------------------ + # Set up SPHIRE global definitions + # ------------------------------------------------------------------------------------ + if sp_global_def.CACHE_DISABLE: + sp_utilities.disable_bdb_cache() + + # Change the name log file for error message + original_logfilename = sp_global_def.LOGFILE + sp_global_def.LOGFILE = ( + os.path.splitext(program_name)[0] + "_" + original_logfilename + ".txt" + ) + + if options.root_dir != None: + root_dir = options.root_dir + else: + root_dir = os.getcwd() + + + start = time.time() + newout = [] + [ + newout.append(entry) if entry.endswith('.star') and not os.path.isdir(entry) + else newout.extend(sorted([entry for entry in glob.glob(os.path.join(entry, '*.star')) + if os.path.isfile(entry)])) + for entry in args if entry.endswith('.star') or os.path.isdir(entry) or '*' in entry + ] + + if options.makevstack is None: + options.makevstack = sys.argv[-1] + + if options.makevstack and options.list: + indicies = list(np.loadtxt(options.list, dtype = int)) + vstack = star.StarFile.add_star(newout, inc_list=indicies ) + vstack.write_star_file(options.makevstack) + + elif options.makevstack and options.exlist: + indicies = list(np.loadtxt(options.exlist, dtype = int)) + vstack = star.StarFile.add_star(newout, exc_list=indicies) + vstack.write_star_file(options.makevstack) + + elif options.makevstack and options.step: + try: + newstep = list(map(int, options.step.split(','))) + except ValueError: + print("Step values need to be integers") + sys.exit(1) + + if len(newstep) < 2 or len(newstep) > 3: + print("Invalid --step specification, requires atleast two values") + sys.exit(1) + + + vstack = star.StarFile.add_star(newout, step=newstep) + vstack.write_star_file(options.makevstack) + + else: + vstack = star.StarFile.add_star(newout) + vstack.write_star_file(options.makevstack) + + print("Time it took to create vstack", time.time() - start) + + + + + + +# ======================================================================================== +# Define main function for command line execution +# ======================================================================================== +def main() : + RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + if RUNNING_UNDER_MPI: + mpi.mpi_init(0, []) # On OS X, there is an error if MPI is initialized and not finalized, hence the conditional + sp_global_def.print_timestamp("Start") + run() + sp_global_def.print_timestamp("Finish") + + if RUNNING_UNDER_MPI: + mpi.mpi_finalize() + + +if __name__ == "__main__": + main() + # RUNNING_UNDER_MPI = "OMPI_COMM_WORLD_SIZE" in os.environ + # if RUNNING_UNDER_MPI: + # mpi.mpi_init(0, []) # On OS X, there is an error if MPI is initialized and not finalized, hence the conditional + # sp_global_def.print_timestamp("Start") + # main() + # sp_global_def.print_timestamp("Finish") + # + # if RUNNING_UNDER_MPI: + # mpi.mpi_finalize() \ No newline at end of file diff --git a/sphire/sphire/bin/sp_viper.py b/sphire/sphire/bin/sp_viper.py index f0f503eb59..e58a8b6fea 100755 --- a/sphire/sphire/bin/sp_viper.py +++ b/sphire/sphire/bin/sp_viper.py @@ -44,11 +44,11 @@ import EMAN2_cppwrap import mpi import optparse -from ..libpy import sp_global_def -from ..libpy import sp_logger -from ..libpy import sp_multi_shc -from ..libpy import sp_user_functions -from ..libpy import sp_utilities +from sphire.libpy import sp_global_def +from sphire.libpy import sp_logger +from sphire.libpy import sp_multi_shc +from sphire.libpy import sp_user_functions +from sphire.libpy import sp_utilities import sys from builtins import range @@ -337,7 +337,7 @@ def run(args): def main(): mpi.mpi_init(0, []) sp_global_def.print_timestamp("Start") - main(sys.argv[1:]) + run(sys.argv[1:]) sp_global_def.print_timestamp("Finish") mpi.mpi_finalize() diff --git a/sphire/sphire/bin/sp_window.py b/sphire/sphire/bin/sp_window.py index ddcb034ab9..a1929aa00e 100755 --- a/sphire/sphire/bin/sp_window.py +++ b/sphire/sphire/bin/sp_window.py @@ -1,5 +1,6 @@ #!/usr/bin/env python +# Author: Adnan Ali 2019 (adnan.ali@mpi-dortmund.mpg.de) # Author: Markus Stabrin 2019 (markus.stabrin@mpi-dortmund.mpg.de) # Author: Fabian Schoenfeld 2019 (fabian.schoenfeld@mpi-dortmund.mpg.de) # Author: Thorsten Wagner 2019 (thorsten.wagner@mpi-dortmund.mpg.de) @@ -47,19 +48,22 @@ import optparse import os import shutil -from ..libpy import sp_applications -from ..libpy import sp_filter -from ..libpy import sp_fundamentals -from ..libpy import sp_global_def -from ..libpy import sp_morphology -from ..libpy import sp_statistics -from ..libpy import sp_utilities +from sphire.libpy import sp_applications +from sphire.libpy import sp_filter +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_morphology +from sphire.libpy import sp_statistics +from sphire.libpy import sp_utilities import sys import time from builtins import range - +try: + from pyStarDB import sp_pystardb as star +except: + print("sp_window requires a python package pyStarDB") # ======================================================================================== # Define functions for reading coordinates files of different formats. @@ -683,6 +687,9 @@ def run(): # List keeps only id substrings of micrographs whose all necessary information are available valid_mic_id_substr_list = [] + #Modified by Adnan (31/9/21) + # Inserting the names of the filenames in the list so that we can gather in the end + star_file_names = [] # ==================================================================================== # Obtain the list of micrograph id sustrings using a single CPU (i.e. main mpi process) # ==================================================================================== @@ -1625,12 +1632,17 @@ def run(): # -------------------------------------------------------------------------------- # Generate the output file path of particle stack for this mpi process # -------------------------------------------------------------------------------- + # Modified by Adnan (31/9/2021) + ## Modified code to integrate star file instead of bdb mic_baseroot = mic_baseroot_pattern.replace("*", mic_id_substr) - local_stack_path = "bdb:%s#" % mpi_proc_dir + mic_baseroot + "_ptcls" + # local_stack_path = "bdb:%s#" % mpi_proc_dir + mic_baseroot + "_ptcls" + local_stack_path = "%s/" % mpi_proc_dir + mic_baseroot + "_ptcls" + ".star" local_mrcs_name = mic_baseroot + "_ptcls.mrcs" - local_mrcs_path = os.path.join(mpi_proc_dir, local_mrcs_name) - + # local_mrcs_path = os.path.join(mpi_proc_dir, local_mrcs_name) + local_mrcs_path = os.path.join(os.path.relpath(mpi_proc_dir, os.getcwd()), local_mrcs_name) local_bdb_stack = EMAN2db.db_open_dict(local_stack_path) + + star_file_names.append(local_stack_path) # -------------------------------------------------------------------------------- # Prepare coordinates loop variables # -------------------------------------------------------------------------------- @@ -1772,7 +1784,8 @@ def run(): ] = ( coords_id ) # NOTE: Toshio Moriya 2017/11/20: same as ptcl_source_coord_id but the other program uses this header entry key... - particle_img_dict["data_path"] = "../" + local_mrcs_name + # particle_img_dict["data_path"] = "../" + local_mrcs_name + particle_img_dict["data_path"] = local_mrcs_path particle_img_dict["resample_ratio"] = resample_ratio particle_img_dict["nx"] = box_size @@ -1959,6 +1972,9 @@ def run(): main_mpi_proc, mpi.MPI_COMM_WORLD, ) + all_star_files = sp_utilities.wrap_mpi_gatherv(star_file_names, 0, mpi.MPI_COMM_WORLD) + else: + all_star_files = star_file_names # Print out the summary of all micrographs if main_mpi_proc == my_mpi_proc_id: @@ -2019,26 +2035,34 @@ def run(): """Multiline Comment0""" if RUNNING_UNDER_MPI: - e2bdb_command = ( - "e2bdb.py " - + root_out_dir - + "/mpi_proc_* --makevstack=bdb:" - + root_out_dir - + "#data" - ) - sp_global_def.sxprint(" ") - sp_global_def.sxprint( - "Please execute from the command line : ", e2bdb_command - ) + # e2bdb_command = ( + # "e2bdb.py " + # + root_out_dir + # + "/mpi_proc_* --makevstack=bdb:" + # + root_out_dir + # + "#data" + # ) + # sp_global_def.sxprint(" ") + # sp_global_def.sxprint( + # "Please execute from the command line : ", e2bdb_command + # ) + if main_mpi_proc == my_mpi_proc_id: + for name in all_star_files: + while not os.path.exists(name): + time.sleep(0.5) + newstar = star.StarFile.add_star(all_star_files) + newstar.write_star_file(os.path.join(root_out_dir, "data.star")) else: - e2bdb_command = ( - "e2bdb.py " - + root_out_dir - + " --makevstack=bdb:" - + root_out_dir - + "#data" - ) - sp_utilities.cmdexecute(e2bdb_command, printing_on_success=False) + # e2bdb_command = ( + # "e2bdb.py " + # + root_out_dir + # + " --makevstack=bdb:" + # + root_out_dir + # + "#data" + # ) + newstar = star.StarFile.add_star(all_star_files) + newstar.write_star_file(os.path.join(root_out_dir, "data.star")) + # sp_utilities.cmdexecute(e2bdb_command, printing_on_success=False) sp_global_def.sxprint(" ") sp_global_def.sxprint("DONE!!!") diff --git a/sphire/sphire/libpy/sp_alignment.py b/sphire/sphire/libpy/sp_alignment.py index 98ab1fce5e..cbfe82c23c 100755 --- a/sphire/sphire/libpy/sp_alignment.py +++ b/sphire/sphire/libpy/sp_alignment.py @@ -1471,6 +1471,196 @@ def ali_vol_func_shift(params, data): return res +def proj_ali_incore(data, refrings, numr, xrng, yrng, step, finfo=None, sym="c1", delta_psi=0.0, rshift=0.0): + from sphire.libpy.sp_alignment import search_range + from EMAN2 import Vec2f + from EMAN2 import Util, Transform + if finfo: + from sphire.libpy.sp_utilities import get_params_proj + phi, theta, psi, s2x, s2y = get_params_proj(data) + finfo.write("Old parameters: %9.4f %9.4f %9.4f %9.4f %9.4f\n" % (phi, theta, psi, s2x, s2y)) + finfo.flush() + + mode = "F" + # center is in SPIDER convention + nx = data.get_xsize() + ny = data.get_ysize() + cnx = nx // 2 + 1 + cny = ny // 2 + 1 + + # phi, theta, psi, sxo, syo = get_params_proj(data) + t1 = data.get_attr("xform.projection") + dp = t1.get_params("spider") + ou = numr[-3] + sxi = round(-dp["tx"] + rshift, 2) + syi = round(-dp["ty"] + rshift, 2) + txrng = search_range(nx, ou, sxi, xrng) + tyrng = search_range(ny, ou, syi, yrng) + + [ang, sxs, sys, mirror, iref, peak] = Util.multiref_polar_ali_3d(data, refrings, txrng, tyrng, step, mode, numr, + cnx - sxi, cny - syi, delta_psi) + # print ang, sxs, sys, mirror, iref, peak + iref = int(iref) + # What that means is that one has to change the the Eulerian angles so they point into mirrored direction: phi+180, 180-theta, 180-psi + # rotation has to be reversed + if mirror: + phi = (refrings[iref].get_attr("phi") + 540.0) % 360.0 + theta = 180.0 - refrings[iref].get_attr("theta") + psi = (540.0 - refrings[iref].get_attr("psi") - ang) % 360.0 + else: + phi = refrings[iref].get_attr("phi") + theta = refrings[iref].get_attr("theta") + psi = (360.0 + refrings[iref].get_attr("psi") - ang) % 360.0 + s2x = sxs + sxi + s2y = sys + syi + # set_params_proj(data, [phi, theta, psi, s2x, s2y]) + t2 = Transform({"type": "spider", "phi": phi, "theta": theta, "psi": psi}) + t2.set_trans(Vec2f(-s2x, -s2y)) + data.set_attr("xform.projection", t2) + data.set_attr("referencenumber", iref) + + from sphire.libpy.sp_pixel_error import max_3D_pixel_error + + ts = t2.get_sym_proj(sym) + if (len(ts) > 1): + # only do it if it is not c1 + pixel_error = +1.0e23 + for ut in ts: + # we do not care which position minimizes the error + pixel_error = min(max_3D_pixel_error(t1, ut, numr[-3]), pixel_error) + else: + pixel_error = max_3D_pixel_error(t1, t2, numr[-3]) + + if finfo: + finfo.write("New parameters: %9.4f %9.4f %9.4f %9.4f %9.4f %10.5f %11.3e\n\n" % ( + phi, theta, psi, s2x, s2y, peak, pixel_error)) + finfo.flush() + + return peak, pixel_error + + +def proj_ali_incore_local(data, refrings, list_of_reference_angles, numr, xrng, yrng, step, an, finfo=None, sym='c1', + delta_psi=0.0, rshift=0.0): + from sphire.libpy.sp_alignment import search_range + # from utilities import set_params_proj, get_params_proj + from math import cos, sin, pi, radians + from EMAN2 import Vec2f + from EMAN2 import Util, Transform + + mode = "F" + nx = data.get_xsize() + ny = data.get_ysize() + # center is in SPIDER convention + cnx = nx // 2 + 1 + cny = ny // 2 + 1 + + ant = cos(radians(an)) + # phi, theta, psi, sxo, syo = get_params_proj(data) + t1 = data.get_attr("xform.projection") + dp = t1.get_params("spider") + ou = numr[-3] + sxi = round(-dp["tx"] + rshift, 2) + syi = round(-dp["ty"] + rshift, 2) + txrng = search_range(nx, ou, sxi, xrng) + tyrng = search_range(ny, ou, syi, yrng) + if finfo: + finfo.write("Old parameters: %6.2f %6.2f %6.2f %6.2f %6.2f\n" % ( + dp["phi"], dp["theta"], dp["psi"], -dp["tx"], -dp["ty"])) + finfo.write( + "ou, nx, ny, xrng, yrng, cnx, cny, sxi, syi, txrng[0],txrng[1],tyrng[0],tyrng[1] : %3d %3d %3d %4.1f %4.1f %3d %3d %4.1f %4.1f %4.1f %4.1f %4.1f %4.1f\n" % ( + ou, nx, ny, xrng, yrng, cnx, cny, sxi, syi, txrng[0], txrng[1], tyrng[0], tyrng[1])) + finfo.flush() + + [ang, sxs, sys, mirror, iref, peak] = Util.multiref_polar_ali_3d_local(data, refrings, list_of_reference_angles, + txrng, tyrng, step, ant, mode, numr, + cnx - sxi, cny - syi, sym, delta_psi) + + iref = int(iref) + if iref > -1: + # What that means is that one has to change the the Eulerian angles so they point into mirrored direction: phi+180, 180-theta, 180-psi + if mirror: + phi = (refrings[iref].get_attr("phi") + 540.0) % 360.0 + theta = 180.0 - refrings[iref].get_attr("theta") + psi = (540.0 - refrings[iref].get_attr("psi") - ang) % 360.0 + else: + phi = refrings[iref].get_attr("phi") + theta = refrings[iref].get_attr("theta") + psi = (360.0 + refrings[iref].get_attr("psi") - ang) % 360.0 + s2x = sxs + sxi + s2y = sys + syi + + # set_params_proj(data, [phi, theta, psi, s2x, s2y]) + t2 = Transform({"type": "spider", "phi": phi, "theta": theta, "psi": psi}) + t2.set_trans(Vec2f(-s2x, -s2y)) + data.set_attr("xform.projection", t2) + from sphire.libpy.sp_pixel_error import max_3D_pixel_error + ts = t2.get_sym_proj(sym) + if (len(ts) > 1): + # only do it if it is not c1 + pixel_error = +1.0e23 + for ut in ts: + # we do not care which position minimizes the error + pixel_error = min(max_3D_pixel_error(t1, ut, numr[-3]), pixel_error) + else: + pixel_error = max_3D_pixel_error(t1, t2, numr[-3]) + # print phi, theta, psi, s2x, s2y, peak, pixel_error + if finfo: + from sphire.libpy.sp_utilities import get_params_proj + phi, theta, psi, s2x, s2y = get_params_proj(data) + finfo.write("New parameters: %6.2f %6.2f %6.2f %6.2f %6.2f %10.5f %11.3e\n\n" % ( + phi, theta, psi, s2x, s2y, peak, pixel_error)) + finfo.flush() + return peak, pixel_error + else: + return -1.0e23, 0.0 + + +def generate_list_of_reference_angles_for_search(input_angles, sym): + """ + Generate full set of reference angles, including mirror and symmetry related + from a unique subrange generated by even_angles and stored in refrings. + Input - input_angles [[angles],[angles]] + Output - [[angles], [angles]] (no shifts) + Blocks - [[basic][mirrored basic]] [[basic sym1][mirrored basic sym1]] ... + """ + from EMAN2 import Transform + t2 = Transform() + nsym = t2.get_nsym(sym) + + original_number_of_angles = len(input_angles) + # original_number_of_angles is the same as the number of refrings + + list_of_reference_angles = [None] * original_number_of_angles + for i in range(original_number_of_angles): + list_of_reference_angles[i] = [input_angles[i][0], input_angles[i][1], 0] + + # add mirror related + list_of_reference_angles += [[0.0, 0.0, 0.0] for i in range(original_number_of_angles)] + for i in range(original_number_of_angles): + list_of_reference_angles[i + original_number_of_angles][0] = (list_of_reference_angles[i][0] + 180.0) % 360.0 + list_of_reference_angles[i + original_number_of_angles][1] = 180.0 - list_of_reference_angles[i][1] + list_of_reference_angles[i + original_number_of_angles][2] = list_of_reference_angles[i][2] + + # add symmetry related + if (nsym > 1): + number_of_angles_original_and_mirror = len(list_of_reference_angles) + for l in range(1, nsym): + list_of_reference_angles += [[0.0, 0.0, 0.0] for i in range(number_of_angles_original_and_mirror)] + + for i in range(number_of_angles_original_and_mirror): + t2 = Transform( + {"type": "spider", "phi": list_of_reference_angles[i][0], "theta": list_of_reference_angles[i][1]}) + ts = t2.get_sym_proj(sym) + for ll in range(1, nsym, 1): + d = ts[ll].get_params("spider") + list_of_reference_angles[i + ll * number_of_angles_original_and_mirror][0] = round(d["phi"], 5) + list_of_reference_angles[i + ll * number_of_angles_original_and_mirror][1] = round(d["theta"], 5) + list_of_reference_angles[i + ll * number_of_angles_original_and_mirror][2] = round(d["psi"], + 5) # Not needed? + + return list_of_reference_angles + + """Multiline Comment53""" diff --git a/sphire/sphire/libpy/sp_applications.py b/sphire/sphire/libpy/sp_applications.py index 9b53897b1b..fdd6a301c8 100755 --- a/sphire/sphire/libpy/sp_applications.py +++ b/sphire/sphire/libpy/sp_applications.py @@ -47,20 +47,27 @@ import numpy import os import random -from . import sp_alignment -from . import sp_filter -from . import sp_fundamentals -from . import sp_global_def -from . import sp_logger -from . import sp_morphology -from . import sp_pixel_error -from . import sp_projection -from . import sp_reconstruction -from . import sp_statistics -from . import sp_user_functions -from . import sp_utilities +from sphire.libpy import sp_alignment +from sphire.libpy import sp_filter +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_logger +from sphire.libpy import sp_morphology +from sphire.libpy import sp_pixel_error +from sphire.libpy import sp_projection +from sphire.libpy import sp_reconstruction +from sphire.libpy import sp_statistics +from sphire.libpy import sp_user_functions +from sphire.libpy import sp_utilities import sys import time +import tqdm + +try: + from pyStarDB import sp_pystardb as star + STAR_AVAILABLE = True +except ImportError: + STAR_AVAILABLE = False def ali2d_MPI( @@ -2811,7 +2818,7 @@ def header( nimage = EMAN2_cppwrap.EMUtil.get_image_count(stack) ext = sp_utilities.file_type(stack) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB = EMAN2db.db_open_dict(stack) for i in range(nimage): if fimport != None: @@ -2861,7 +2868,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align2d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -2889,7 +2896,7 @@ def header( {"type": "spider", "phi": phi, "theta": theta, "psi": psi} ) t.set_trans(EMAN2_cppwrap.Vec2f(-s2x, -s2y)) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.projection", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -2922,7 +2929,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align3d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -2931,14 +2938,14 @@ def header( il += 8 elif p[: len("members")] == "members": members = [int(entry) for entry in line.strip("[]\n \t").split(",")] - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "members", members) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( stack, "members", members, i ) elif p.startswith("ISAC_SPLIT_"): - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p.strip(), line.strip()) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -2960,7 +2967,7 @@ def header( ctf = sp_utilities.generate_ctf( [defocus, cs, voltage, apix, bfactor, ampcont, dfdiff, dfang] ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "ctf", ctf) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute(stack, "ctf", ctf, i) @@ -2969,7 +2976,7 @@ def header( # if len(params)!=len(parmvalues): # print "Error: %d params need to be set, while %d values are provided in line %d of file." % ( len(params), len(parmvalues), i ) # return - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p, extract_value(parmvalues[il])) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -2998,7 +3005,7 @@ def header( "scale": 1.0, } ) - if ext == "bdb": + if ext == "bdb" or ext =="star": DB.set_attr(i, "xform.align2d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3007,7 +3014,7 @@ def header( elif p[:16] == "xform.projection": # set_params_proj(img, [0.0, 0.0, 0.0, 0.0, 0.0], p) t = EMAN2_cppwrap.Transform({"type": "spider"}) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.projection", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3016,7 +3023,7 @@ def header( elif p[:13] == "xform.align3d": # set_params3D(img, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0, 1.0], p) t = EMAN2_cppwrap.Transform({"type": "spider"}) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align3d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3027,7 +3034,7 @@ def header( return else: # img.set_attr(p, 0) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p, 0) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute(stack, p, 0, i) @@ -3037,7 +3044,7 @@ def header( return else: # img.set_attr(p, 1) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p, 1) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute(stack, p, 1, i) @@ -3047,12 +3054,12 @@ def header( return else: # img.set_attr(p, 1) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p, set) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute(stack, p, set, i) elif consecutive: - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, p, i) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute(stack, p, i, i) @@ -3074,7 +3081,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align2d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3091,7 +3098,7 @@ def header( {"type": "spider", "phi": phi, "theta": theta, "psi": psi} ) t.set_trans(EMAN2_cppwrap.Vec2f(-s2x, -s2y)) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.projection", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3120,7 +3127,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align3d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3147,7 +3154,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align2d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3165,7 +3172,7 @@ def header( {"type": "spider", "phi": phi, "theta": theta, "psi": psi} ) t.set_trans(EMAN2_cppwrap.Vec2f(-s2x, -s2y)) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.projection", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3194,7 +3201,7 @@ def header( "scale": scale, } ) - if ext == "bdb": + if ext == "bdb" or ext == "star": DB.set_attr(i, "xform.align3d", t) elif ext == "hdf": EMAN2_cppwrap.EMUtil.write_hdf_attribute( @@ -3207,7 +3214,7 @@ def header( elif fexport != None: if p[:13] == "xform.align2d": # alpha, sx, sy, mirror, scale = get_params2D(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.align2d") d = t.get_params("2D") fexp.write( @@ -3239,7 +3246,7 @@ def header( elif p[:16] == "xform.projection": # phi, theta, psi, s2x, s2y = get_params_proj(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.projection") d = t.get_params("spider") fexp.write( @@ -3259,7 +3266,7 @@ def header( elif p[:13] == "xform.align3d": # phi, theta, psi, s3x, s3y, s3z, mirror, scale = get_params3D(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.align3d") d = t.get_params("spider") fexp.write( @@ -3297,7 +3304,7 @@ def header( elif p == "ctf": # defocus, cs, voltage, apix, bfactor, ampcont = get_ctf(img) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "ctf") elif ext == "hdf": t = EMAN2_cppwrap.EMUtil.read_hdf_attribute(stack, "ctf", i) @@ -3316,7 +3323,7 @@ def header( ) else: - if ext == "bdb": + if ext == "bdb" or ext == "star": fexp.write("%15s " % str(DB.get_attr(i, p))) elif ext == "hdf": @@ -3329,7 +3336,7 @@ def header( elif fprint: if p[:13] == "xform.align2d": # alpha, sx, sy, mirror, scale = get_params2D(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.align2d") d = t.get_params("2D") print( @@ -3362,7 +3369,7 @@ def header( ) elif p[:16] == "xform.projection": # phi, theta, psi, s2x, s2y = get_params_proj(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.projection") d = t.get_params("spider") print( @@ -3382,7 +3389,7 @@ def header( ) elif p[:13] == "xform.align3d": # phi, theta, psi, s3x, s3y, s3z, mirror, scale = get_params3D(img, p) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "xform.align3d") d = t.get_params("spider") print( @@ -3420,7 +3427,7 @@ def header( ) elif p == "ctf": # defocus, cs, voltage, apix, bfactor, ampcont = get_ctf(img) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, "ctf") elif ext == "hdf": t = EMAN2_cppwrap.EMUtil.read_hdf_attribute(stack, "ctf", i) @@ -3440,7 +3447,7 @@ def header( ) else: - if ext == "bdb": + if ext == "bdb" or ext == "star": print("%15s" % str(DB.get_attr(i, p)), end=" ") elif ext == "hdf": print( @@ -3453,7 +3460,7 @@ def header( elif backup: # t = img.get_attr(p) # img.set_attr(p+suffix, t) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, p) DB.set_attr(i, p + suffix, t) elif ext == "hdf": @@ -3479,7 +3486,7 @@ def header( # t= EMUtil.read_hdf_attribute(stack,p,i) if p[:13] == "xform.align2d": # img.set_attr(p[:13], t) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, p) DB.set_attr(i, "xform.align2d", t) elif ext == "hdf": @@ -3489,7 +3496,7 @@ def header( ) elif p[:16] == "xform.projection": # img.set_attr(p[:10], t) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, p) DB.set_attr(i, "xform.projection", t) elif ext == "hdf": @@ -3499,7 +3506,7 @@ def header( ) elif p[:13] == "xform.align3d": # img.set_attr(p[:13], t) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, p) DB.set_attr(i, "xform.align3d", t) elif ext == "hdf": @@ -3510,7 +3517,7 @@ def header( ) else: # img.set_attr(p[:-len(suffix)], t) - if ext == "bdb": + if ext == "bdb" or ext == "star": t = DB.get_attr(i, p) DB.set_attr(i, p[: -len(suffix)], t) elif ext == "hdf": @@ -3529,9 +3536,12 @@ def header( fexp.write("\n") if fprint: print(" ") - if ext == "bdb": + if ext == "bdb" : DB.close() + if ext == "star": + EMAN2db.db_close_dict(stack) + def MPI_start_end(nima, nproc, myid): image_start = int(round(old_div(float(nima), nproc) * myid)) @@ -4283,14 +4293,530 @@ def wrapper_params_2D_to_3D(stack): nima = EMAN2.EMUtil.get_image_count(stack) ima = EMAN2.EMData() - for im in range(nima): + for im in tqdm.tqdm(range(nima), desc="Wrapping params 2D to 3D"): ima.read_image(stack, im, True) p = sp_utilities.get_params2D(ima) p = sp_utilities.params_2D_3D(p[0], p[1], p[2], int(p[3])) sp_utilities.set_params_proj(ima, p) sp_utilities.write_header(stack, ima, im) +def wrapper_params_2D_to_3D_star(stack): + from pyStarDB import sp_pystardb as star + nima = EMAN2.EMUtil.get_image_count(stack) + star_file = star.StarFile(stack) + + try: + dataframes = star_file['particles'] + except KeyError: + dataframes = star_file[''] + for im in tqdm.tqdm(range(nima), desc="Wrapping params 2D to 3D"): + alpha = dataframes.loc[im, "_rlnAnglePsi"] + tx = dataframes.loc[im, "_rlnOriginX"] + ty = dataframes.loc[im, "_rlnOriginY"] + mirror = 0 + scale = 1.0 + phi, theta, psi, s2x, s2y = sp_utilities.params_2D_3D(alpha, tx, ty, mirror) + rowindex = dataframes.index[im] + dataframes.loc[rowindex, "_rlnAnglePsi"] = psi + dataframes.loc[rowindex, "_rlnAngleRot"] = phi + dataframes.loc[rowindex, "_rlnAngleTilt"] = theta + dataframes.loc[rowindex, "_rlnOriginX"] = -s2x + dataframes.loc[rowindex, "_rlnOriginY"] = -s2y + + star_file.update('particles', dataframes, True) + print(star_file['particles']["_rlnAngleRot"]) + star_file.write_star_file(overwrite=True) + + +def Kmref_ali3d_MPI(stack, ref_vol, outdir, maskfile=None, focus=None, maxit=1, ir=1, ou=-1, rs=1, + xr="4 2 2 1", yr="-1", ts="1 1 0.5 0.25", delta="10 6 4 4", an="-1", + center=-1, nassign=3, nrefine=1, CTF=False, snr=1.0, ref_a="S", sym="c1", + user_func_name="ref_ali3d", npad=4, debug=False, fourvar=False, termprec=0.0, mpi_comm=None, + log=None): + from sphire.libpy.sp_utilities import model_circle, reduce_EMData_to_root, bcast_EMData_to_all, bcast_number_to_all, drop_image + from sphire.libpy.sp_utilities import bcast_list_to_all, get_image, get_input_from_string, get_im + from sphire.libpy.sp_utilities import get_arb_params, set_arb_params, drop_spider_doc, send_attr_dict + from sphire.libpy.sp_utilities import get_params_proj, set_params_proj, model_blank, write_text_row, write_text_file + from sphire.libpy.sp_filter import filt_params, filt_btwl, filt_ctf, filt_table, fit_tanh, filt_tanl + from sphire.libpy.sp_utilities import rotate_3D_shift, estimate_3D_center_MPI + from sphire.libpy.sp_alignment import Numrinit, prepare_refrings, proj_ali_incore + from random import randint + from sphire.libpy.sp_filter import filt_ctf + from sphire.libpy.sp_utilities import print_begin_msg, print_end_msg, print_msg + from sphire.libpy.sp_projection import prep_vol, prgs, project, prgq, gen_rings_ctf + from sphire.libpy.sp_utilities import wrap_mpi_recv, wrap_mpi_send + from copy import deepcopy + import os + import types + from mpi import mpi_bcast, mpi_comm_size, mpi_comm_rank, MPI_FLOAT, MPI_COMM_WORLD, mpi_barrier + from mpi import mpi_reduce, MPI_INT, MPI_SUM + from EMAN2 import EMData, EMUtil, Transform + + if mpi_comm == None: mpi_comm = MPI_COMM_WORLD + number_of_proc = mpi_comm_size(mpi_comm) + myid = mpi_comm_rank(mpi_comm) + main_node = 0 + if log == None: + from sphire.libpy.sp_logger import Logger + log = Logger() + + if os.path.exists(outdir): sp_global_def.ERROR('Output directory exists, please change the name and restart the program', + "Kmref_ali3d_MPI ", 1, myid) + mpi_barrier(MPI_COMM_WORLD) + + if myid == main_node: + os.mkdir(outdir) + from sphire.libpy import sp_global_def + sp_global_def.LOGFILE = os.path.join(outdir, sp_global_def.LOGFILE) + log.add("Kmref_ali3d_MPI - Traditional Kmeans clustering !") + mpi_barrier(MPI_COMM_WORLD) + + from time import time + + if debug: + from time import sleep + while not os.path.exists(outdir): + sxprint("Node ", myid, " waiting...") + sleep(5) + + finfo = open(os.path.join(outdir, "progress%04d" % myid), 'w') + frec = open(os.path.join(outdir, "recons%04d" % myid), "w") + else: + finfo = None + frec = None + + xrng = get_input_from_string(xr) + if yr == "-1": + yrng = xrng + else: + yrng = get_input_from_string(yr) + step = get_input_from_string(ts) + delta = get_input_from_string(delta) + lstp = min(len(xrng), len(yrng), len(step), len(delta)) + if an == "-1": + an = [] + for i in range(len(xrng)): an.append(-1) + else: + from sphire.libpy.sp_alignment import proj_ali_incore_local + an = get_input_from_string(an) + + first_ring = int(ir) + rstep = int(rs) + last_ring = int(ou) + center = int(center) + + numref = EMUtil.get_image_count(ref_vol) + volref = EMData() + volref.read_image(stack, 0) + nx = volref.get_xsize() + if last_ring < 0: last_ring = nx // 2 - 2 + + fscmask = model_circle(last_ring, nx, nx, nx) + + if myid == main_node: + from sphire.libpy import sp_user_functions + user_func = sp_user_functions.factory[user_func_name] + log.add("Input stack : %s" % (stack)) + log.add("Reference volumes : %s" % (ref_vol)) + log.add("Number of reference volumes : %i" % (numref)) + log.add("Output directory : %s" % (outdir)) + log.add("User function : %s" % (user_func_name)) + log.add("Maskfile : %s" % (maskfile)) + log.add("Inner radius : %i" % (first_ring)) + log.add("Outer radius : %i" % (last_ring)) + log.add("Ring step : %i" % (rstep)) + log.add("X search range : %s" % (xrng)) + log.add("Y search range : %s" % (yrng)) + log.add("Translational step : %s" % (step)) + log.add("Angular step : %s" % (delta)) + log.add("Angular search range : %s" % (an)) + log.add("Number of assignments in each iteration : %i" % (nassign)) + log.add("Number of alignments in each iteration : %i" % (nrefine)) + log.add("Number of iterations : %i" % (lstp * maxit)) + log.add("Center type : %i" % (center)) + log.add("CTF correction : %s" % (CTF)) + log.add("Signal-to-Noise Ratio : %f" % (snr)) + log.add("Reference projection method : %s" % (ref_a)) + log.add("Symmetry group : %s" % (sym)) + log.add("Percentage of change for termination: %f" % (termprec)) + log.add("User function : %s" % (user_func_name)) + + if maskfile: + #if type(maskfile) is bytes or str: + if isinstance(maskfile, (bytes, str)): + mask3D = get_image(maskfile) + else: + mask3D = maskfile + else: + mask3D = model_circle(last_ring, nx, nx, nx) + + numr = Numrinit(first_ring, last_ring, rstep, "F") + mask2D = model_circle(last_ring, nx, nx) - model_circle(first_ring, nx, nx) + + if myid == main_node: + nima = EMUtil.get_image_count(stack) + list_of_particles = list(range(nima)) + else: + nima = 0 + + nima = bcast_number_to_all(nima, source_node=main_node) + + if myid != main_node: + list_of_particles = [-1] * nima + + list_of_particles = bcast_list_to_all(list_of_particles, myid, source_node=main_node) + + image_start, image_end = MPI_start_end(nima, number_of_proc, myid) + # create a list of images for each node + total_nima = nima + list_of_particles = list_of_particles[image_start: image_end] + nima = len(list_of_particles) + + if debug: + finfo.write("Image_start, image_end: %d %d\n" % (image_start, image_end)) + finfo.flush() + + start_time = time() + data = EMData.read_images(stack, list_of_particles) + if myid == main_node: + log.add("Time to read data: %d\n" % (time() - start_time)); + start_time = time() + # Initialize Particle ID and set group number to non-existant -1 + assignment = [-1] * len(data) + for im in range(len(data)): + data[im].set_attr_dict({'ID': list_of_particles[im], 'group': -1}) + + if fourvar: + from sphire.libpy.sp_reconstruction import rec3D_MPI + from sphire.libpy.sp_statistics import varf3d_MPI + # Compute Fourier variance + vol, fscc = rec3D_MPI(data, snr, sym, fscmask, os.path.join(outdir, "resolution0000"), myid, main_node, + finfo=frec, npad=npad) + varf = varf3d_MPI(data, os.path.join(outdir, "ssnr0000"), None, vol, last_ring, 1.0, 1, CTF, 1, sym, myid) + if myid == main_node: + varf = 1.0 / varf + varf.write_image(os.path.join(outdir, "varf0000.hdf")) + else: + varf = None + if myid == main_node: + for iref in range(numref): + get_im(ref_vol, iref).write_image(os.path.join(outdir, "volf0000.hdf"), iref) + mpi_barrier(MPI_COMM_WORLD) + + if CTF: + if (data[0].get_attr("ctf_applied") > 0.0): sp_global_def.ERROR("Kmref_ali3d_MPI does not work for CTF-applied data", + "Kmref_ali3d_MPI", 1, myid) + from sphire.libpy.sp_reconstruction import rec3D_MPI + else: + from sphire.libpy.sp_reconstruction import rec3D_MPI_noCTF + + if debug: + finfo.write('%d loaded \n' % len(data)) + finfo.flush() + + # this is needed for gathering of pixel errors + disps = [] + recvcount = [] + for im in range(number_of_proc): + if im == main_node: + disps.append(0) + else: + disps.append(disps[im - 1] + recvcount[im - 1]) + ib, ie = MPI_start_end(total_nima, number_of_proc, im) + recvcount.append(ie - ib) + + total_iter = 0 + tr_dummy = Transform({"type": "spider"}) + + Niter = int(lstp * maxit * (nassign + nrefine)) + for Iter in range(Niter): + N_step = int((Iter % (lstp * (nassign + nrefine))) / (nassign + nrefine)) + if Iter % (nassign + nrefine) < nassign: + runtype = "ASSIGNMENT" + else: + runtype = "REFINEMENT" + + total_iter += 1 + if myid == main_node: + log.add( + "\n%s ITERATION #%3d, inner iteration #%3d\nDelta = %4.1f, an = %5.2f, xrange = %5.2f, yrange = %5.2f, step = %5.2f" % ( + runtype, total_iter, Iter, delta[N_step], an[N_step], xrng[N_step], yrng[N_step], step[N_step])) + start_ime = time() + + peaks = [-1.0e23] * nima + if runtype == "REFINEMENT": + trans = [tr_dummy] * nima + pixer = [0.0] * nima + if (an[N_step] > 0): + from sphire.libpy.sp_utilities import even_angles + ref_angles = even_angles(delta[N_step], symmetry=sym, method=ref_a, phiEqpsi="Zero") + # generate list of angles + from sphire.libpy.sp_alignment import generate_list_of_reference_angles_for_search + list_of_reference_angles = \ + generate_list_of_reference_angles_for_search(ref_angles, sym=sym) + del ref_angles + else: + list_of_reference_angles = [[1.0, 1.0]] + + cs = [0.0] * 3 + for iref in range(numref): + if myid == main_node: + volft = get_im(os.path.join(outdir, "volf%04d.hdf" % (total_iter - 1)), iref) + else: + volft = model_blank(nx, nx, nx) + bcast_EMData_to_all(volft, myid, main_node) + volft, kb = prep_vol(volft) + + if CTF: + previous_defocus = -1.0 + if runtype == "REFINEMENT": + start_time = time() + prjref = prgq(volft, kb, nx, delta[N_step], ref_a, sym, MPI=True) + if myid == main_node: + log.add("Calculation of projections: %d" % (time() - start_time)); + start_time = time() + del volft, kb + else: + if runtype == "REFINEMENT": + start_time = time() + refrings = prepare_refrings(volft, kb, nx, delta[N_step], ref_a, sym, numr) + if myid == main_node: + log.add("Initial time to prepare rings: %d" % (time() - start_time)); + start_time = time() + del volft, kb + + start_time = time() + for im in range(nima): + if CTF: + ctf = data[im].get_attr("ctf") + if runtype == "REFINEMENT": + if ctf.defocus != previous_defocus: + previous_defocus = ctf.defocus + rstart_time = time() + refrings = gen_rings_ctf(prjref, nx, ctf, numr) + if myid == main_node: + log.add("Repeated time to prepare rings: %d" % (time() - rstart_time)); + rstart_time = time() + + if runtype == "ASSIGNMENT": + phi, tht, psi, s2x, s2y = get_params_proj(data[im]) + ref = prgs(volft, kb, [phi, tht, psi, -s2x, -s2y]) + if CTF: ref = filt_ctf(ref, ctf) + peak = ref.cmp("ccc", data[im], {"mask": mask2D, "negative": 0}) + if not (finfo is None): + finfo.write("ID,iref,peak: %6d %d %8.5f\n" % (list_of_particles[im], iref, peak)) + else: + if an[N_step] == -1: + peak, pixel_error = proj_ali_incore(data[im], refrings, numr, xrng[N_step], yrng[N_step], + step[N_step]) + else: + peak, pixel_error = proj_ali_incore_local(data[im], refrings, list_of_reference_angles, numr, \ + xrng[N_step], yrng[N_step], step[N_step], an[N_step]) + if not (finfo is None): + phi, tht, psi, s2x, s2y = get_params_proj(data[im]) + finfo.write("ID,iref,peak,trans: %6d %d %f %f %f %f %f %f\n" % ( + list_of_particles[im], iref, peak, phi, tht, psi, s2x, s2y)) + finfo.flush() + + if peak > peaks[im]: + peaks[im] = peak + data[im].set_attr('group', iref) + if runtype == "REFINEMENT": + pixer[im] = pixel_error + trans[im] = data[im].get_attr("xform.projection") + if not (finfo is None): + finfo.write(" current best\n") + finfo.flush() + else: + if not (finfo is None): + finfo.write("\n") + finfo.flush() + if myid == main_node: + log.add("Time to process particles for reference %3d: %d" % (iref, time() - start_time)); + start_time = time() + + del peaks + if runtype == "ASSIGNMENT": + del volft, kb, ref + else: + if CTF: del prjref + del refrings + if an[N_step] > 0: del list_of_reference_angles + + # compute number of particles that changed assignment and how man are in which group + nchng = 0 + npergroup = [0] * numref + for im in range(nima): + iref = data[im].get_attr('group') + npergroup[iref] += 1 + if iref != assignment[im]: + assignment[im] = iref + nchng += 1 + nchng = mpi_reduce(nchng, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD) + npergroup = mpi_reduce(npergroup, numref, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD) + npergroup = list(map(int, npergroup)) + terminate = 0 + empty_group = 0 + if myid == main_node: + nchng = int(nchng[0]) + precn = 100 * float(nchng) / float(total_nima) + msg = " Number of particles that changed assignments %7d, percentage of total: %5.1f" % (nchng, precn) + log.add(msg) + msg = " Group number of particles" + log.add(msg) + for iref in range(numref): + msg = " %5d %7d" % (iref + 1, npergroup[iref]) + log.add(msg) + if npergroup[iref] == 0: + empty_group = 1 + if precn <= termprec: + terminate = 1 + if empty_group == 1: + terminate = 1 + terminate = mpi_bcast(terminate, 1, MPI_INT, 0, MPI_COMM_WORLD) + terminate = int(terminate[0]) + empty_group = mpi_bcast(empty_group, 1, MPI_INT, 0, MPI_COMM_WORLD) + empty_group = int(empty_group[0]) + if empty_group == 1: break # program stops whenever empty_group appears! + if runtype == "REFINEMENT": + for im in range(nima): + data[im].set_attr('xform.projection', trans[im]) + + if center == -1: + cs[0], cs[1], cs[2], dummy, dummy = estimate_3D_center_MPI(data, total_nima, myid, number_of_proc, + main_node) + if myid == main_node: + msg = " Average center x = %10.3f Center y = %10.3f Center z = %10.3f" % ( + cs[0], cs[1], cs[2]) + log.add(msg) + cs = mpi_bcast(cs, 3, MPI_FLOAT, main_node, MPI_COMM_WORLD) + cs = [-float(cs[0]), -float(cs[1]), -float(cs[2])] + rotate_3D_shift(data, cs) + # output pixel errors + from mpi import mpi_gatherv + recvbuf = mpi_gatherv(pixer, nima, MPI_FLOAT, recvcount, disps, MPI_FLOAT, main_node, MPI_COMM_WORLD) + mpi_barrier(MPI_COMM_WORLD) + if myid == main_node: + recvbuf = list(map(float, recvbuf)) + from sphire.libpy.sp_statistics import hist_list + lhist = 20 + region, histo = hist_list(recvbuf, lhist) + if region[0] < 0.0: region[0] = 0.0 + msg = " Histogram of pixel errors\n ERROR number of particles" + log.add(msg) + for lhx in range(lhist): + msg = " %10.3f %7d" % (region[lhx], histo[lhx]) + log.add(msg) + del region, histo + del recvbuf + + for im in range(nima): + phi, theta, psi, tx, ty = get_params_proj(data[im]) + trans[im] = [phi, theta, psi, tx, ty] + if myid == main_node: + all_trans = [] + for klm in range(number_of_proc): + if (klm == main_node): + all_trans.extend(deepcopy(trans)) + else: + all_trans.extend(wrap_mpi_recv(klm, MPI_COMM_WORLD)) + else: + wrap_mpi_send(trans, main_node, MPI_COMM_WORLD) + if myid == main_node: + write_text_row(all_trans, os.path.join(outdir, "params_%04d.txt" % (total_iter))) + del all_trans + + if myid == main_node: + all_trans = [] + for klm in range(number_of_proc): + if (klm == main_node): + all_trans.extend(deepcopy(assignment)) + else: + all_trans.extend(wrap_mpi_recv(klm, MPI_COMM_WORLD)) + else: + wrap_mpi_send(assignment, main_node, MPI_COMM_WORLD) + if myid == main_node: + write_text_file(all_trans, os.path.join(outdir, "assignment_%04d.txt" % (total_iter))) + del all_trans + + # if CTF: del vol + fscc = [None] * numref + + if fourvar and runtype == "REFINEMENT": + sumvol = model_blank(nx, nx, nx) + + sart_time = time() + for iref in range(numref): + # 3D stuff + from time import localtime, strftime + if CTF: + volref, fscc[iref] = rec3D_MPI(data, snr, sym, fscmask, + os.path.join(outdir, "resolution_%02d_%04d.txt" % (iref, total_iter)), + myid, main_node, index=iref, npad=npad, finfo=frec) + else: + volref, fscc[iref] = rec3D_MPI_noCTF(data, sym, fscmask, os.path.join(outdir, + "resolution_%02d_%04d.txt" % ( + iref, total_iter)), myid, + main_node, index=iref, npad=npad, finfo=frec) + if myid == main_node: + log.add("Time to compute 3D: %d" % (time() - start_time)); + start_time = time() + + if myid == main_node: + volref.write_image(os.path.join(outdir, "vol%04d.hdf" % (total_iter)), iref) + if fourvar and runtype == "REFINEMENT": + sumvol += volref + del volref + + if runtype == "REFINEMENT": + if fourvar: + varf = varf3d_MPI(data, os.path.join(outdir, "ssnr%04d" % total_iter), None, sumvol, last_ring, 1.0, 1, + CTF, 1, sym, myid) + if myid == main_node: + varf = 1.0 / varf + varf.write_image(os.path.join(outdir, "varf%04d.hdf" % total_iter)) + + if myid == main_node: + refdata = [None] * 7 + refdata[0] = numref + refdata[1] = outdir + refdata[2] = None + refdata[3] = total_iter + refdata[4] = varf + refdata[5] = mask3D + refdata[6] = (runtype == "REFINEMENT") # whether align on 50S, this only happens at refinement step + user_func(refdata) + + # here we write header info + mpi_barrier(MPI_COMM_WORLD) + # start_time = time() + # if runtype=="REFINEMENT": + # par_str = ['xform.projection', 'ID', 'group'] + # else: + # par_str = ['group', 'ID' ] + # if myid == main_node: + # from utilities import file_type + # if file_type(stack) == "bdb": + # from utilities import recv_attr_dict_bdb + # recv_attr_dict_bdb(main_node, stack, data, par_str, image_start, image_end, number_of_proc) + # else: + # from utilities import recv_attr_dict + # recv_attr_dict(main_node, stack, data, par_str, image_start, image_end, number_of_proc) + # else: send_attr_dict(main_node, data, par_str, image_start, image_end) + if terminate == 1: + if myid == main_node: + log.add("Kmref_ali3d_MPI terminated due to small number of objects changing assignments") + break + # if myid == main_node: + # log.add( "Time to write headers: %d\n" % (time()-start_time) );start_time = time() + ######writing paritition only in the end of the program + mpi_barrier(MPI_COMM_WORLD) + """Multiline Comment22""" + + if myid == main_node: + log.add("Kmref_ali3d_MPI is done!") + return empty_group # print_end_msg("params_2D_to_3D") """Multiline Comment61""" diff --git a/sphire/sphire/libpy/sp_filter.py b/sphire/sphire/libpy/sp_filter.py index 4e54518372..02f11de521 100755 --- a/sphire/sphire/libpy/sp_filter.py +++ b/sphire/sphire/libpy/sp_filter.py @@ -408,4 +408,51 @@ def filterlocal(ui, vi, m, falloff, myid, main_node, number_of_proc): return filteredvol +def filt_params(dres, high = 0.95, low = 0.1): + """ + Name + filt_params - using the FSC curve establish two frequencies: stop-band, corresponding to the point where the curves drops below predefined high value, and pass-band, corresponding to the point where the curves drops below predefined low value + Input + dres - list produced by the fsc funcion + dres[0] - absolute frequencies + dres[1] - fsc, because it was calculated from half the dataset, convert it to full using rn = 2r/(1+r) + dres[2] - number of point use to calculate fsc coeff + low: cutoff of the fsc curve + high: cutoff of the fsc curve. Note: high and low values are optional. + return parameters of the Butterworth filter (low and high frequencies) + Output + freql: stop-band frequency + freqh: pass-band frequency + """ + n = len(dres[1]) + if ( (2*dres[1][n-1]/(1.0+dres[1][n-1])) > low): + # the curve never falls below preset level, most likely something's wrong; however, return reasonable values + # First, find out whether it actually does fall + nend = 0 + for i in range(n-1,1,-1): + if ( (2*dres[1][i]/(1.0+dres[1][i]) ) < low): + nend = i + break + if( nend == 0 ): + #it does not fall anywhere + freql = 0.4 + freqh = 0.4999 + return freql,freqh + else: + n = nend +1 + # normal case + freql = 0.001 # this is in case the next loop does not work and the curve never drops below high + for i in range(1,n-1): + if ( (2*dres[1][i]/(1.0+dres[1][i]) ) < high): + freql = dres[0][i] + break + freqh = 0.1 # this is in case the next loop does not work and the curve never rises above low + for i in range(n-2,0,-1): + if ( (2*dres[1][i]/(1.0+dres[1][i]) ) > low): + freqh =min( max(dres[0][i], freql+0.1), 0.45) + break + return freql,freqh + + + from builtins import range diff --git a/sphire/sphire/libpy/sp_multi_shc.py b/sphire/sphire/libpy/sp_multi_shc.py index 386a684104..0bdad0e9e2 100755 --- a/sphire/sphire/libpy/sp_multi_shc.py +++ b/sphire/sphire/libpy/sp_multi_shc.py @@ -45,19 +45,19 @@ import mpi import os import random -from . import sp_alignment -from . import sp_applications -from . import sp_filter -from . import sp_fundamentals -from . import sp_global_def -from . import sp_logger -from . import sp_morphology -from . import sp_pixel_error -from . import sp_projection -from . import sp_reconstruction -from . import sp_statistics -from . import sp_utilities -from ..libpy.sp_utilities import getvec, getfvec, getang3, lacos, angles_to_normals +from sphire.libpy import sp_alignment +from sphire.libpy import sp_applications +from sphire.libpy import sp_filter +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_logger +from sphire.libpy import sp_morphology +from sphire.libpy import sp_pixel_error +from sphire.libpy import sp_projection +from sphire.libpy import sp_reconstruction +from sphire.libpy import sp_statistics +from sphire.libpy import sp_utilities +from sphire.libpy.sp_utilities import getvec, getfvec, getang3, lacos, angles_to_normals import time diff --git a/sphire/sphire/libpy/sp_projection.py b/sphire/sphire/libpy/sp_projection.py index af9a092208..6a563ec886 100755 --- a/sphire/sphire/libpy/sp_projection.py +++ b/sphire/sphire/libpy/sp_projection.py @@ -265,3 +265,86 @@ def prep_vol(vol, npad=2, interpolation_method=-1): volft.fft_shuffle() volft.set_attr("npad", npad) return volft + +def prgq( volft, kb, nx, delta, ref_a, sym, MPI=False): + """ + Generate set of projections based on even angles + The command returns list of ffts of projections + """ + from sphire.libpy.sp_projection import prep_vol, prgs + from sphire.libpy.sp_applications import MPI_start_end + from sphire.libpy.sp_utilities import even_angles, model_blank + from sphire.libpy.sp_fundamentals import fft + # generate list of Eulerian angles for reference projections + # phi, theta, psi + mode = "F" + ref_angles = even_angles(delta, symmetry=sym, method = ref_a, phiEqpsi = "Minus") + cnx = nx//2 + 1 + cny = nx//2 + 1 + num_ref = len(ref_angles) + + if MPI: + from mpi import mpi_comm_rank, mpi_comm_size, MPI_COMM_WORLD + myid = mpi_comm_rank( MPI_COMM_WORLD ) + ncpu = mpi_comm_size( MPI_COMM_WORLD ) + else: + ncpu = 1 + myid = 0 + from sphire.libpy.sp_applications import MPI_start_end + ref_start,ref_end = MPI_start_end( num_ref, ncpu, myid ) + + prjref = [] # list of (image objects) reference projections in Fourier representation + + for i in range(num_ref): + prjref.append(model_blank(nx, nx)) # I am not sure why is that necessary, why not put None's?? + + for i in range(ref_start, ref_end): + prjref[i] = prgs(volft, kb, [ref_angles[i][0], ref_angles[i][1], ref_angles[i][2], 0.0, 0.0]) + + if MPI: + from sphire.libpy.sp_utilities import bcast_EMData_to_all + for i in range(num_ref): + for j in range(ncpu): + ref_start,ref_end = MPI_start_end(num_ref,ncpu,j) + if i >= ref_start and i < ref_end: rootid = j + bcast_EMData_to_all( prjref[i], myid, rootid ) + + for i in range(len(ref_angles)): + prjref[i].set_attr_dict({"phi": ref_angles[i][0], "theta": ref_angles[i][1],"psi": ref_angles[i][2]}) + + return prjref + +def gen_rings_ctf( prjref, nx, ctf, numr): + """ + Convert set of ffts of projections to Fourier rings with additional multiplication by a ctf + The command returns list of rings + """ + from EMAN2 import Util + from math import sin, cos, pi + from sphire.libpy.sp_fundamentals import fft + from sphire.libpy.sp_alignment import ringwe + from sphire.libpy.sp_filter import filt_ctf + mode = "F" + wr_four = ringwe(numr, "F") + cnx = nx//2 + 1 + cny = nx//2 + 1 + qv = pi/180.0 + + refrings = [] # list of (image objects) reference projections in Fourier representation + + for i in range( len(prjref) ): + cimage = Util.Polar2Dm(filt_ctf(prjref[i], ctf, True) , cnx, cny, numr, mode) # currently set to quadratic.... + Util.Normalize_ring(cimage, numr, 0 ) + + Util.Frngs(cimage, numr) + Util.Applyws(cimage, numr, wr_four) + refrings.append(cimage) + phi = prjref[i].get_attr('phi') + theta = prjref[i].get_attr('theta') + psi = prjref[i].get_attr('psi') + n1 = sin(theta*qv)*cos(phi*qv) + n2 = sin(theta*qv)*sin(phi*qv) + n3 = cos(theta*qv) + refrings[i].set_attr_dict( {"n1":n1, "n2":n2, "n3":n3, "phi": phi, "theta": theta,"psi": psi} ) + + return refrings diff --git a/sphire/sphire/libpy/sp_reconstruction.py b/sphire/sphire/libpy/sp_reconstruction.py index d275e11885..593f668cd5 100755 --- a/sphire/sphire/libpy/sp_reconstruction.py +++ b/sphire/sphire/libpy/sp_reconstruction.py @@ -863,6 +863,637 @@ def recons3d_4nn_ctf_MPI( return fftvol + + +def get_image_size( imgdata, myid ): + from mpi import mpi_gather, mpi_bcast, MPI_COMM_WORLD, MPI_INT + nimg = len(imgdata) + + nimgs = mpi_gather( nimg, 1, MPI_INT, 1, MPI_INT, 0, MPI_COMM_WORLD ) + + if myid==0: + src = -1 + for i in range( len(nimgs) ): + if int(nimgs[i]) > 0 : + src = i + break + if src==-1: + return 0 + else: + src = -1 + + size_src = mpi_bcast( src, 1, MPI_INT, 0, MPI_COMM_WORLD ) + + if myid==int(size_src[0]): + assert nimg > 0 + size = imgdata[0].get_xsize() + else: + size = -1 + + nx = mpi_bcast( size, 1, MPI_INT, size_src[0], MPI_COMM_WORLD ) + return int(nx[0]) + +def prepare_recons_ctf(nx, data, snr, symmetry, myid, main_node_half, half_start, step, finfo=None, npad = 2, mpi_comm=None, smearstep = 0.0): + from random import randint + from sphire.libpy.sp_utilities import reduce_EMData_to_root + from mpi import mpi_barrier, MPI_COMM_WORLD + from EMAN2 import EMData, Reconstructors + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + fftvol_half = EMData() + + if( smearstep > 0.0 ): + #if myid == 0: print " Setting smear in prepare_recons_ctf" + ns = 1 + smear = [] + for j in range(-ns,ns+1): + if( j != 0): + for i in range(-ns,ns+1): + for k in range(-ns,ns+1): + smear += [i*smearstep,j*smearstep,k*smearstep,1.0] + # Deal with theta = 0.0 cases + prj = [] + for i in range(-ns,ns+1): + for k in range(-ns,ns+1): + prj.append(i+k) + for i in range(-2*ns,2*ns+1,1): + smear += [i*smearstep,0.0,0.0,float(prj.count(i))] + #if myid == 0: print " Smear ",smear + fftvol_half.set_attr("smear", smear) + + weight_half = EMData() + half_params = {"size":nx, "npad":npad, "snr":snr, "sign":1, "symmetry":symmetry, "fftvol":fftvol_half, "weight":weight_half} + half = Reconstructors.get( "nn4_ctf", half_params ) + half.setup() + + for i in range(half_start, len(data), step): + xform_proj = data[i].get_attr( "xform.projection" ) + half.insert_slice(data[i], xform_proj ) + + if not(finfo is None): + finfo.write( "begin reduce half\n" ) + finfo.flush() + + reduce_EMData_to_root(fftvol_half, myid, main_node_half, mpi_comm) + reduce_EMData_to_root(weight_half, myid, main_node_half, mpi_comm) + + if not(finfo is None): + finfo.write( "after reduce half\n" ) + finfo.flush() + + if myid == main_node_half: + tmpid = randint(0, 1000000) + fftvol_half_file = ("fftvol_half%d.hdf" % tmpid) + weight_half_file = ("weight_half%d.hdf" % tmpid) + fftvol_half.write_image(fftvol_half_file) + weight_half.write_image(weight_half_file) + mpi_barrier(mpi_comm) + + fftvol_half = None + weight_half = None + + if myid == main_node_half: + return fftvol_half_file, weight_half_file + + return None,None + +def recons_ctf_from_fftvol(size, fftvol, weight, snr, symmetry, weighting=1, npad = 2): + from EMAN2 import Reconstructors + + params = {"size":size, "npad":npad, "snr":snr, "sign":1, "symmetry":symmetry, "fftvol":fftvol, "weight":weight, "weighting":weighting} + r = Reconstructors.get("nn4_ctf", params) + r.setup() + dummy = r.finish(True) + return fftvol + + +def rec3D_MPI(data, snr=1.0, symmetry="c1", mask3D=None, fsc_curve=None, \ + myid=0, main_node=0, rstep=1.0, odd_start=0, eve_start=1, finfo=None, \ + index=-1, npad=2, mpi_comm=None, smearstep=0.0): + ''' + This function is to be called within an MPI program to do a reconstruction on a dataset kept + in the memory, computes reconstruction and through odd-even, in order to get the resolution + ''' + import os + from sphire.libpy.sp_statistics import fsc_mask + from sphire.libpy.sp_utilities import model_blank, model_circle, get_image, send_EMData, recv_EMData + from mpi import mpi_comm_size, MPI_COMM_WORLD + from EMAN2 import Util + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + nproc = mpi_comm_size(mpi_comm) + + if nproc == 1: + assert main_node == 0 + main_node_odd = main_node + main_node_eve = main_node + main_node_all = main_node + elif nproc == 2: + main_node_odd = main_node + main_node_eve = (main_node + 1) % 2 + main_node_all = main_node + + tag_voleve = 1000 + tag_fftvol_eve = 1001 + tag_weight_eve = 1002 + else: + # spread CPUs between different nodes to save memory + main_node_odd = main_node + main_node_eve = (int(main_node) + nproc - 1) % int(nproc) + main_node_all = (int(main_node) + nproc // 2) % int(nproc) + + tag_voleve = 1000 + tag_fftvol_eve = 1001 + tag_weight_eve = 1002 + + tag_fftvol_odd = 1003 + tag_weight_odd = 1004 + tag_volall = 1005 + + if index != -1: + grpdata = [] + for i in range(len(data)): + if data[i].get_attr('group') == index: + grpdata.append(data[i]) + imgdata = grpdata + else: + imgdata = data + + nx = get_image_size(imgdata, myid) + if nx == 0: + ERROR( + "Warning: no images were given for reconstruction, this usually means there is an empty group, returning empty volume", + "rec3D", 0) + return model_blank(2, 2, 2), None + + fftvol_odd_file, weight_odd_file = prepare_recons_ctf(nx, imgdata, snr, symmetry, myid, main_node_odd, odd_start, 2, + finfo, npad, mpi_comm=mpi_comm, smearstep=smearstep) + fftvol_eve_file, weight_eve_file = prepare_recons_ctf(nx, imgdata, snr, symmetry, myid, main_node_eve, eve_start, 2, + finfo, npad, mpi_comm=mpi_comm, smearstep=smearstep) + del imgdata + + if nproc == 1: + fftvol = get_image(fftvol_odd_file) + weight = get_image(weight_odd_file) + volodd = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + + fftvol = get_image(fftvol_eve_file) + weight = get_image(weight_eve_file) + voleve = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + + if (not mask3D): + nx = volodd.get_xsize() + ny = volodd.get_ysize() + nz = volodd.get_zsize() + mask3D = model_circle(min(nx, ny, nz) // 2 - 2, nx, ny, nz) + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve, mask3d + + fftvol = get_image(fftvol_odd_file) + fftvol_tmp = get_image(fftvol_eve_file) + fftvol += fftvol_tmp + fftvol_tmp = None + + weight = get_image(weight_odd_file) + weight_tmp = get_image(weight_eve_file) + weight += weight_tmp + weight_tmp = None + + volall = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file) + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file) + + return volall, fscdat + + if nproc == 2: + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + weight = get_image(weight_odd_file) + volodd = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + voleve = recv_EMData(main_node_eve, tag_voleve, mpi_comm) + + if (not mask3D): + nx = volodd.get_xsize() + ny = volodd.get_ysize() + nz = volodd.get_zsize() + mask3D = model_circle(min(nx, ny, nz) // 2 - 2, nx, ny, nz) + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve, mask3D + else: + assert myid == main_node_eve + fftvol = get_image(fftvol_eve_file) + weight = get_image(weight_eve_file) + voleve = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + send_EMData(voleve, main_node_odd, tag_voleve, mpi_comm) + + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + fftvol_tmp = recv_EMData(main_node_eve, tag_fftvol_eve, mpi_comm) + fftvol += fftvol_tmp + fftvol_tmp = None + + weight = get_image(weight_odd_file) + weight_tmp = recv_EMData(main_node_eve, tag_weight_eve, mpi_comm) + weight += weight_tmp + weight_tmp = None + + volall = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file) + + return volall, fscdat + else: + assert myid == main_node_eve + fftvol = get_image(fftvol_eve_file) + weight = get_image(weight_eve_file) + send_EMData(fftvol, main_node_odd, tag_fftvol_eve, mpi_comm) + send_EMData(weight, main_node_odd, tag_weight_eve, mpi_comm) + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file) + return model_blank(nx, nx, nx), None + + # cases from all other number of processors situations + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + send_EMData(fftvol, main_node_eve, tag_fftvol_odd, mpi_comm) + + if not (finfo is None): + finfo.write("fftvol odd sent\n") + finfo.flush() + + weight = get_image(weight_odd_file) + send_EMData(weight, main_node_all, tag_weight_odd, mpi_comm) + + if not (finfo is None): + finfo.write("weight odd sent\n") + finfo.flush() + + volodd = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + del fftvol, weight + voleve = recv_EMData(main_node_eve, tag_voleve, mpi_comm) + + if (not mask3D): + nx = volodd.get_xsize() + ny = volodd.get_ysize() + nz = volodd.get_zsize() + mask3D = model_circle(min(nx, ny, nz) // 2 - 2, nx, ny, nz) + + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve, mask3D + volall = recv_EMData(main_node_all, tag_volall, mpi_comm) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file) + return volall, fscdat + + if myid == main_node_eve: + ftmp = recv_EMData(main_node_odd, tag_fftvol_odd, mpi_comm) + fftvol = get_image(fftvol_eve_file) + Util.add_img(ftmp, fftvol) + send_EMData(ftmp, main_node_all, tag_fftvol_eve, mpi_comm) + del ftmp + + weight = get_image(weight_eve_file) + send_EMData(weight, main_node_all, tag_weight_eve, mpi_comm) + + voleve = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + send_EMData(voleve, main_node_odd, tag_voleve, mpi_comm) + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file); + + return model_blank(nx, nx, nx), None + + if myid == main_node_all: + fftvol = recv_EMData(main_node_eve, tag_fftvol_eve, mpi_comm) + if not (finfo is None): + finfo.write("fftvol odd received\n") + finfo.flush() + + weight = recv_EMData(main_node_odd, tag_weight_odd, mpi_comm) + weight_tmp = recv_EMData(main_node_eve, tag_weight_eve, mpi_comm) + Util.add_img(weight, weight_tmp) + weight_tmp = None + + volall = recons_ctf_from_fftvol(nx, fftvol, weight, snr, symmetry, npad=npad) + send_EMData(volall, main_node_odd, tag_volall, mpi_comm) + + return model_blank(nx, nx, nx), None + + return model_blank(nx, nx, nx), None + + + +def prepare_recons(data, symmetry, myid, main_node_half, half_start, step, index, finfo=None, npad = 2, mpi_comm=None): + from random import randint + from sphire.libpy.sp_utilities import reduce_EMData_to_root + from mpi import mpi_barrier, MPI_COMM_WORLD + from EMAN2 import EMData, Reconstructors + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + nx = data[0].get_xsize() + + fftvol_half = EMData() + weight_half = EMData() + half_params = {"size":nx, "npad":npad, "symmetry":symmetry, "fftvol":fftvol_half, "weight":weight_half} + half = Reconstructors.get( "nn4", half_params ) + half.setup() + + group = -1 + for i in range(half_start, len(data), step): + if(index >-1 ): group = data[i].get_attr('group') + if(group == index): + # horatio active_refactoring Jy51i1EwmLD4tWZ9_00000_1 + # if( data[i].get_attr_default('active',1) == 1): + # xform_proj = data[i].get_attr( "xform.projection" ) + # half.insert_slice(data[i], xform_proj ) + xform_proj = data[i].get_attr( "xform.projection" ) + half.insert_slice(data[i], xform_proj ) + + if not(finfo is None): + finfo.write( "begin reduce half\n" ) + finfo.flush() + + reduce_EMData_to_root(fftvol_half, myid, main_node_half, mpi_comm) + reduce_EMData_to_root(weight_half, myid, main_node_half, mpi_comm) + + if not(finfo is None): + finfo.write( "after reduce half\n" ) + finfo.flush() + + if myid == main_node_half: + tmpid = randint(0, 1000000) + fftvol_half_file = ("fftvol_half%d.hdf" % tmpid) + weight_half_file = ("weight_half%d.hdf" % tmpid) + fftvol_half.write_image(fftvol_half_file) + weight_half.write_image(weight_half_file) + mpi_barrier(mpi_comm) + + fftvol_half = None + weight_half = None + + if myid == main_node_half: return fftvol_half_file, weight_half_file + + return None, None + + +def rec3D_MPI_noCTF(data, symmetry="c1", mask3D=None, fsc_curve=None, myid=2, main_node=0, \ + rstep=1.0, odd_start=0, eve_start=1, finfo=None, index=-1, npad=2, mpi_comm=None): + ''' + This function is to be called within an MPI program to do a reconstruction on a dataset kept in the memory + Computes reconstruction and through odd-even, in order to get the resolution + if index > -1, projections should have attribute group set and only those whose group matches index will be used in the reconstruction + this is for multireference alignment + ''' + import os + from sphire.libpy.sp_statistics import fsc_mask + from sphire.libpy.sp_utilities import model_blank, get_image, send_EMData, recv_EMData + from mpi import mpi_comm_size, MPI_COMM_WORLD + from EMAN2 import Util + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + nproc = mpi_comm_size(mpi_comm) + + if nproc == 1: + assert main_node == 0 + main_node_odd = main_node + main_node_eve = main_node + main_node_all = main_node + elif nproc == 2: + main_node_odd = main_node + main_node_eve = (main_node + 1) % 2 + main_node_all = main_node + + tag_voleve = 1000 + tag_fftvol_eve = 1001 + tag_weight_eve = 1002 + else: + # spread CPUs between different nodes to save memory + main_node_odd = main_node + main_node_eve = (int(main_node) + nproc - 1) % int(nproc) + main_node_all = (int(main_node) + nproc // 2) % int(nproc) + + tag_voleve = 1000 + tag_fftvol_eve = 1001 + tag_weight_eve = 1002 + + tag_fftvol_odd = 1003 + tag_weight_odd = 1004 + tag_volall = 1005 + + nx = data[0].get_xsize() + + fftvol_odd_file, weight_odd_file = prepare_recons(data, symmetry, myid, main_node_odd, odd_start, 2, index, finfo, + npad, mpi_comm=mpi_comm) + fftvol_eve_file, weight_eve_file = prepare_recons(data, symmetry, myid, main_node_eve, eve_start, 2, index, finfo, + npad, mpi_comm=mpi_comm) + + if nproc == 1: + fftvol = get_image(fftvol_odd_file) + weight = get_image(weight_odd_file) + volodd = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + + fftvol = get_image(fftvol_eve_file) + weight = get_image(weight_eve_file) + voleve = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve + + fftvol = get_image(fftvol_odd_file) + Util.add_img(fftvol, get_image(fftvol_eve_file)) + + weight = get_image(weight_odd_file) + Util.add_img(weight, get_image(weight_eve_file)) + + volall = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file); + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file); + return volall, fscdat + + if nproc == 2: + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + weight = get_image(weight_odd_file) + volodd = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + voleve = recv_EMData(main_node_eve, tag_voleve, mpi_comm) + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve + else: + assert myid == main_node_eve + fftvol = get_image(fftvol_eve_file) + weight = get_image(weight_eve_file) + voleve = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + send_EMData(voleve, main_node_odd, tag_voleve, mpi_comm) + + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + fftvol_tmp = recv_EMData(main_node_eve, tag_fftvol_eve, mpi_comm) + Util.add_img(fftvol, fftvol_tmp) + fftvol_tmp = None + + weight = get_image(weight_odd_file) + weight_tmp = recv_EMData(main_node_eve, tag_weight_eve, mpi_comm) + Util.add_img(weight, weight_tmp) + weight_tmp = None + volall = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file); + return volall, fscdat + else: + assert myid == main_node_eve + fftvol = get_image(fftvol_eve_file) + send_EMData(fftvol, main_node_odd, tag_fftvol_eve, mpi_comm) + + weight = get_image(weight_eve_file) + send_EMData(weight, main_node_odd, tag_weight_eve, mpi_comm) + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file); + return model_blank(nx, nx, nx), None + # cases from all other number of processors situations + if myid == main_node_odd: + fftvol = get_image(fftvol_odd_file) + send_EMData(fftvol, main_node_eve, tag_fftvol_odd, mpi_comm) + + if not (finfo is None): + finfo.write("fftvol odd sent\n") + finfo.flush() + + weight = get_image(weight_odd_file) + send_EMData(weight, main_node_all, tag_weight_odd, mpi_comm) + + if not (finfo is None): + finfo.write("weight odd sent\n") + finfo.flush() + + volodd = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + del fftvol, weight + voleve = recv_EMData(main_node_eve, tag_voleve, mpi_comm) + fscdat = fsc_mask(volodd, voleve, mask3D, rstep, fsc_curve) + del volodd, voleve + volall = recv_EMData(main_node_all, tag_volall, mpi_comm) + os.system("rm -f " + fftvol_odd_file + " " + weight_odd_file); + return volall, fscdat + + if myid == main_node_eve: + ftmp = recv_EMData(main_node_odd, tag_fftvol_odd, mpi_comm) + fftvol = get_image(fftvol_eve_file) + Util.add_img(ftmp, fftvol) + send_EMData(ftmp, main_node_all, tag_fftvol_eve, mpi_comm) + del ftmp + + weight = get_image(weight_eve_file) + send_EMData(weight, main_node_all, tag_weight_eve, mpi_comm) + + voleve = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + send_EMData(voleve, main_node_odd, tag_voleve, mpi_comm) + os.system("rm -f " + fftvol_eve_file + " " + weight_eve_file); + + return model_blank(nx, nx, nx), None + + if myid == main_node_all: + fftvol = recv_EMData(main_node_eve, tag_fftvol_eve, mpi_comm) + if not (finfo is None): + finfo.write("fftvol odd received\n") + finfo.flush() + + weight = recv_EMData(main_node_odd, tag_weight_odd, mpi_comm) + weight_tmp = recv_EMData(main_node_eve, tag_weight_eve, mpi_comm) + Util.add_img(weight, weight_tmp) + weight_tmp = None + + volall = recons_from_fftvol(nx, fftvol, weight, symmetry, npad) + send_EMData(volall, main_node_odd, tag_volall, mpi_comm) + + return model_blank(nx, nx, nx), None + +def recons3d_nn_SSNR_MPI(myid, prjlist, mask2D, ring_width=1, npad =1, sign=1, symmetry="c1", CTF = False, random_angles = 0, mpi_comm = None): + from sphire.libpy.sp_utilities import reduce_EMData_to_root + from EMAN2 import EMData, Reconstructors, Transform, Util + from mpi import MPI_COMM_WORLD + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + if( len(prjlist) == 0 ): ERROR("empty input list","recons3d_nn_SSNR_MPI",1) + imgsize = prjlist[0].get_xsize() + if prjlist[0].get_ysize() != imgsize: ERROR("input data has to be square","recons3d_nn_SSNR_MPI",1) + fftvol = EMData() + weight = EMData() + weight2 = EMData() + SSNR = EMData() + vol_ssnr = EMData() + params = {"size":imgsize, "npad":npad, "symmetry":symmetry, "SSNR":SSNR, "fftvol":fftvol, "weight":weight, "weight2":weight2, "vol_ssnr":vol_ssnr, "w":ring_width } + if CTF: + weight3 = EMData() + params["sign"] = sign + params["weight3"] = weight3 + r = Reconstructors.get("nnSSNR_ctf", params) + else: + r = Reconstructors.get("nnSSNR", params) + r.setup() + + if prjlist[0].get_xsize() != imgsize or prjlist[0].get_ysize() != imgsize: ERROR("inconsistent image size","recons3d_nn_SSNR_MPI",1) + for prj in prjlist: + # horatio active_refactoring Jy51i1EwmLD4tWZ9_00000_1 + # active = prj.get_attr_default('active', 1) + # if active == 1: + if random_angles == 2: + from random import random + phi = 360.0*random() + theta = 180.0*random() + psi = 360.0*random() + xform_proj = Transform( {"type":"spider", "phi":phi, "theta":theta, "psi":psi} ) + elif random_angles == 3: + from random import random + phi = 360.0*random() + theta = 180.0*random() + psi = 360.0*random() + tx = 6.0*(random() - 0.5) + ty = 6.0*(random() - 0.5) + xform_proj = Transform( {"type":"spider", "phi":phi, "theta":theta, "psi":psi, "tx":tx, "ty":ty} ) + elif random_angles == 1: + from random import random + old_xform_proj = prj.get_attr( "xform.projection" ) + dict = old_xform_proj.get_rotation( "spider" ) + dict["psi"] = 360.0*random() + xform_proj = Transform( dict ) + else: + xform_proj = prj.get_attr( "xform.projection" ) + if mask2D: + stats = Util.infomask(prj, mask2D, True) + prj -= stats[0] + prj *= mask2D + r.insert_slice(prj, xform_proj ) + # horatio active_refactoring Jy51i1EwmLD4tWZ9_00000_1 END + + #from utilities import info + reduce_EMData_to_root(weight, myid, 0, comm=mpi_comm) + reduce_EMData_to_root(fftvol, myid, 0, comm=mpi_comm) + reduce_EMData_to_root(weight2, myid, 0, comm=mpi_comm) + if CTF: + reduce_EMData_to_root(weight3, myid, 0, comm=mpi_comm) + if myid == 0 : + dummy = r.finish(True) + outlist = [[] for i in range(6)] + nn = SSNR.get_xsize() + for i in range(1,nn): outlist[0].append((float(i)-0.5)/(float(nn-1)*2)) + for i in range(1,nn): + if SSNR(i,1,0) > 0.0: + outlist[1].append(max(0.0,(SSNR(i,0,0)/SSNR(i,1,0)-1.))) # SSNR + else: + outlist[1].append(0.0) + for i in range(1,nn): + if SSNR(i,2,0) > 0.0: + outlist[2].append(SSNR(i,1,0)/SSNR(i,2,0)) # variance + else: + outlist[2].append(0.0) + for i in range(1,nn): outlist[3].append(SSNR(i,2,0)) # number of points in the shell + for i in range(1,nn): outlist[4].append(SSNR(i,3,0)) # number of added Fourier points + for i in range(1,nn): outlist[5].append(SSNR(i,0,0)) # square of signal + return [outlist, vol_ssnr] + + """Multiline Comment11""" from builtins import range diff --git a/sphire/sphire/libpy/sp_statistics.py b/sphire/sphire/libpy/sp_statistics.py index 88d5e52ec2..f69f447996 100755 --- a/sphire/sphire/libpy/sp_statistics.py +++ b/sphire/sphire/libpy/sp_statistics.py @@ -1177,7 +1177,7 @@ def pearson(X, Y): Sxy += x * y return old_div( (Sxy - old_div(Sx * Sy, N)), - numpy.sqrt((Sxx - old_div(Sx * Sx, N)) * (Syy - old_div(Sy * Sy, N))), + numpy.sqrt((Sxx - old_div(Sx * Sx, N)) * (Syy - old_div(Sy * Sy, N))) ) @@ -1574,6 +1574,114 @@ def mono(k1,k2): return min(k1,k2) + old_div(mk*(mk-1),2) # match is a list, where every five tuple corresponds to a match +def varf3d_MPI(prjlist, ssnr_text_file=None, mask2D=None, reference_structure=None, ou=-1, rw=1.0, npad=1, CTF=False, + sign=1, sym="c1", myid=0, mpi_comm=None): + """ + Calculate variance in Fourier space of an object reconstructed from sp_projections + + Known problems: properly speaking, the SSNR has to be calculated using snr=inf and this is what recons3d_nn_SSNR_MPI does. + So, when one computes reference structure, snr should be 1.0e20. However, when the reference structure is passed + from the reconstruction program, it was computed using different snr. I tested it and in practice there is no difference, + as this only changes the background variance due to reconstruction algorithm, which is much lower anyway. PAP. + """ + from sphire.libpy.sp_reconstruction import recons3d_nn_SSNR_MPI, recons3d_4nn_MPI, recons3d_4nn_ctf_MPI + from sphire.libpy.sp_utilities import bcast_EMData_to_all, model_blank + from sphire.libpy.sp_projection import prep_vol, prgs + from mpi import MPI_COMM_WORLD + + if mpi_comm == None: + mpi_comm = MPI_COMM_WORLD + + if myid == 0: + [ssnr1, vol_ssnr1] = recons3d_nn_SSNR_MPI(myid, prjlist, mask2D, rw, npad, sign, sym, CTF, mpi_comm=mpi_comm) + else: + recons3d_nn_SSNR_MPI(myid, prjlist, mask2D, rw, npad, sign, sym, CTF, mpi_comm=mpi_comm) + + nx = prjlist[0].get_xsize() + if ou == -1: + radius = int(nx / 2) - 2 + else: + radius = int(ou) + if (reference_structure == None): + if CTF: + snr = 1.0 # e20 + if myid == 0: + reference_structure = recons3d_4nn_ctf_MPI(myid, prjlist, snr, sign, sym, mpi_comm=mpi_comm) + else: + recons3d_4nn_ctf_MPI(myid, prjlist, snr, sign, sym, mpi_comm=mpi_comm) + reference_structure = model_blank(nx, nx, nx) + else: + if myid == 0: + reference_structure = recons3d_4nn_MPI(myid, prjlist, sym, snr=snr, mpi_comm=mpi_comm) + else: + recons3d_4nn_MPI(myid, prjlist, sym, snr=snr, mpi_comm=mpi_comm) + reference_structure = model_blank(nx, nx, nx) + bcast_EMData_to_all(reference_structure, myid, 0, mpi_comm) + # if myid == 0: reference_structure.write_image("refer.hdf",0) + # vol *= model_circle(radius, nx, nx, nx) + volft, kb = prep_vol(reference_structure) + del reference_structure + from sphire.libpy.sp_utilities import get_params_proj + if CTF: from sphire.libpy.sp_filter import filt_ctf + re_prjlist = [] + for prj in prjlist: + phi, theta, psi, tx, ty = get_params_proj(prj) + proj = prgs(volft, kb, [phi, theta, psi, -tx, -ty]) + if CTF: + ctf_params = prj.get_attr("ctf") + proj = filt_ctf(proj, ctf_params) + proj.set_attr('sign', 1) + re_prjlist.append(proj) + del volft + if myid == 0: + [ssnr2, vol_ssnr2] = recons3d_nn_SSNR_MPI(myid, re_prjlist, mask2D, rw, npad, sign, sym, CTF, mpi_comm=mpi_comm) + else: + recons3d_nn_SSNR_MPI(myid, re_prjlist, mask2D, rw, npad, sign, sym, CTF, mpi_comm=mpi_comm) + del re_prjlist + + if myid == 0 and ssnr_text_file != None: + outf = open(ssnr_text_file, "w") + for i in range(len(ssnr2[0])): + datstrings = [] + datstrings.append(" %15f" % ssnr1[0][i]) # have to subtract 0.5 as in C code there is round. + datstrings.append(" %15e" % ssnr1[1][i]) # SSNR + datstrings.append(" %15e" % ssnr1[2][i]) # variance + datstrings.append(" %15f" % ssnr1[3][i]) # number of points in the shell + datstrings.append(" %15f" % ssnr1[4][i]) # number of added Fourier points + datstrings.append(" %15e" % ssnr1[5][i]) # square of signal + datstrings.append(" %15e" % ssnr2[1][i]) # SSNR + datstrings.append(" %15e" % ssnr2[2][i]) # variance + datstrings.append(" %15e" % ssnr2[5][i]) # square of signal + datstrings.append("\n") + outf.write("".join(datstrings)) + outf.close() + if myid == 0: + vol_ssnr1 = Util.subn_img(Util.pack_complex_to_real(vol_ssnr1), Util.pack_complex_to_real(vol_ssnr2)) + del vol_ssnr2 + # what follows is a risky business. There should be a better way to deal with negative values. but for the time being... + nc = nx // 2 + r2 = radius ** 2 + for i in range(nx): + for j in range(nx): + for k in range(nx): + if (((i - nc) ** 2 + (j - nc) ** 2 + (k - nc) ** 2) < r2): + if (vol_ssnr1.get_value_at(i, j, k) <= 0.0): + bm = -1.0 + for i1 in range(-1, 2): + for i2 in range(-1, 2): + for i3 in range(-1, 2): + tm = vol_ssnr1.get_value_at(i + i1, j + i2, k + i3) + if (tm > bm): + bm = tm + vol_ssnr1.set_value_at(i, j, k, bm) + + else: + vol_ssnr1.set_value_at(i, j, k, 1.0) + return vol_ssnr1 + # from morphology import threshold_to_minval + # return threshold_to_minval( Util.subn_img(Util.pack_complex_to_real(vol_ssnr1), Util.pack_complex_to_real(vol_ssnr2)), 1.0) + else: + return model_blank(2, 2, 2) from builtins import range from builtins import object diff --git a/sphire/sphire/libpy/sp_utilities.py b/sphire/sphire/libpy/sp_utilities.py index cc3d3ca368..30640642ce 100755 --- a/sphire/sphire/libpy/sp_utilities.py +++ b/sphire/sphire/libpy/sp_utilities.py @@ -58,10 +58,10 @@ import scipy.spatial import six -from . import sp_applications -from . import sp_fundamentals -from . import sp_global_def -from . import sp_morphology +from sphire.libpy import sp_applications +from sphire.libpy import sp_fundamentals +from sphire.libpy import sp_global_def +from sphire.libpy import sp_morphology import string import struct import sys @@ -69,6 +69,10 @@ import traceback import zlib +try: + from pyStarDB import sp_pystardb as star +except ImportError: + print("You need pyStarDB package to run this tool, please run pip install pyStarDB") def makerelpath(p1, p2): """Takes a pair of paths /a/b/c/d and /a/b/e/f/g and returns a relative path to b from a, ../../e/f/g""" @@ -940,6 +944,11 @@ def get_im(stackname, im=0): e = EMAN2_cppwrap.EMData() e.read_image(stackname, im) return e + # elif stackname.endswith(".star"): + # if type(stackname) == type(""): + # e = EMAN2.EMData() + # pp = e.read_images(stackname, [im]) + # return pp[0] else: return stackname[im].copy() @@ -2434,6 +2443,13 @@ def write_header(filename, data, lima): if ftp == "bdb": DB = EMAN2db.db_open_dict(filename) DB.set_header(lima, data) + elif ftp == "star": + DB = EMAN2db.db_open_dict(filename) + special_keys = star.StarFile(filename).special_keys + ignored_keys = star.StarFile(filename).ignored_keys + em_dict = data.get_attr_dict() + EMAN2db.db_em_to_star_header(em_dict, DB.converter, lima, special_keys, ignored_keys) + EMAN2db.db_close_dict(filename) elif ftp == "hdf": data.write_image(filename, lima, EMAN2_cppwrap.EMUtil.ImageType.IMAGE_HDF, True) else: @@ -2448,6 +2464,8 @@ def file_type(name): return name[-3:] elif name[-5:] == ".mrcs": return "mrcs" + elif name.endswith('.star'): + return "star" sp_global_def.ERROR("Unacceptable file format", "file_type", 1) diff --git a/sphire/templates/sxgui_template.py b/sphire/templates/sxgui_template.py index 9b23b82b12..3d9467ee5b 100644 --- a/sphire/templates/sxgui_template.py +++ b/sphire/templates/sxgui_template.py @@ -1549,7 +1549,7 @@ def select_file(self, target_widget, file_format = ""): # Read not supported: ;; JPEG (*.jpg *.jpeg) # 2D image stack not supported: ;; Gatan (*.dm2 *.dm3);; EM (*.em);; ICOS (*.icos);; Amira (*.am);; DF3 (*.d3);; FITS (*.fts);; OMAP (*.omap);; PGM (*.pgm);; PNG (*.png);; SAL (*.hdr *.img);; SITUS (*.situs);; TIFF (*.tif *.tiff);; V4L (*.v4l);; VTK (*.vtk);; XPLOR (*.xplor) # Maybe only single 2D image: ;; MRC (*.mrc) - name = QFileDialog.getOpenFileName(self, "Select any image stack file", SXLookFeelConst.file_dialog_dir, "Typical image stack files (*.bdb *.hdf *.mrcs *.spi *.img );; BDB (*.bdb);; HDF (*.hdf);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", options = QFileDialog.DontUseNativeDialog) + name = QFileDialog.getOpenFileName(self, "Select any image stack file", SXLookFeelConst.file_dialog_dir, "Typical image stack files (*.star *.bdb *.hdf *.mrcs *.spi *.img );; STAR (*.star);; BDB (*.bdb);; HDF (*.hdf);; MRCS (*.mrcs);; Spider (*.spi);; Imagic (*.img *hed);; Gatan (*.dm4);; FEI (*.ser);; LST (*.lst);; LSTFAST (*.lsx *.lst);; PIF (*.pif);; All files (*)", options = QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): file_path = str(name[0]) else: @@ -1744,6 +1744,15 @@ def select_file(self, target_widget, file_format = ""): # Use relative path. if file_path: file_path = SXLookFeelConst.format_path(file_path) + elif file_format == "params_star": + name = QFileDialog.getOpenFileName(self, "Select STAR file", SXLookFeelConst.file_dialog_dir, "STAR files (*.star);; All files (*)", options = QFileDialog.DontUseNativeDialog) + if isinstance(name, tuple): + file_path = str(name[0]) + else: + file_path = str(name) + # Use relative path. + if file_path: + file_path = SXLookFeelConst.format_path(file_path) elif file_format == "params_any_json": name = QFileDialog.getOpenFileName(self, "Select JSON file", SXLookFeelConst.file_dialog_dir, "JSON files (*.json);; All files (*)", options = QFileDialog.DontUseNativeDialog) if isinstance(name, tuple): @@ -2386,8 +2395,8 @@ def __init__(self, name, helical, parent=None): temp_btn.setMinimumWidth(func_btn_min_width) grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) elif cmd_token.type == "data2d_stack": - file_format = "bdb2d_stack" - temp_btn = QPushButton("Select BDB image stack") + file_format = cmd_token.type + temp_btn = QPushButton("Select Star image stack") temp_btn.setMinimumWidth(func_btn_min_width) temp_btn.setToolTip(''+"Display open file dialog to select a BDB format image stack file") grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 2, token_widget_row_span, token_widget_col_span) @@ -2618,6 +2627,47 @@ def __init__(self, name, helical, parent=None): temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') temp_btn.setMinimumWidth(func_btn_min_width) grid_layout.addWidget(temp_btn, grid_row, grid_col_origin + token_label_col_span + token_widget_col_span * 3, token_widget_row_span, token_widget_col_span) + elif cmd_token.type == "params_star": + file_format = cmd_token.type + temp_btn = QPushButton("Select STAR file") + temp_btn.setMinimumWidth(func_btn_min_width) + temp_btn.setToolTip('' + "Display open file dialog to select a STAR file") + grid_layout.addWidget(temp_btn, grid_row,grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect(partial(self.sxcmdwidget.select_file, + cmd_token_widget, file_format)) + file_format = "INVISIBLE" + temp_btn = QPushButton("%s" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) + temp_btn.setEnabled(False) + temp_btn.setStyleSheet('background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0);' + ' border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setMinimumWidth(func_btn_min_width) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) + elif cmd_token.type == "submission_temp": + file_format = cmd_token.type + file_format = "sh" + temp_btn = QPushButton("Select template") + temp_btn.setMinimumWidth(func_btn_min_width) + temp_btn.setToolTip( + '' + "Display open file dialog to select a parameters text file") + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 2, + token_widget_row_span, token_widget_col_span) + temp_btn.clicked.connect( + partial(self.sxcmdwidget.select_file, cmd_token_widget, file_format)) + file_format = "INVISIBLE" + temp_btn = QPushButton("%s" % file_format) + temp_btn.setToolTip('' + "This is %s button" % file_format) + temp_btn.setEnabled(False) + temp_btn.setStyleSheet( + 'background: rgba(0, 0, 0, 0); color: rgba(0, 0, 0, 0); border: 0px rgba(0, 0, 0, 0) solid') + temp_btn.setMinimumWidth(func_btn_min_width) + grid_layout.addWidget(temp_btn, grid_row, + grid_col_origin + token_label_col_span + token_widget_col_span * 3, + token_widget_row_span, token_widget_col_span) elif cmd_token.type == "params_any_json": file_format = cmd_token.type temp_btn = QPushButton("Select JSON file") diff --git a/sphire/templates/wikiparser.py b/sphire/templates/wikiparser.py index d8fdf887d5..f3090c337d 100644 --- a/sphire/templates/wikiparser.py +++ b/sphire/templates/wikiparser.py @@ -398,12 +398,19 @@ def handle_exceptional_cases(sxcmd): assert(sxcmd.token_dict["selection_list"].key_base == "selection_list") assert(sxcmd.token_dict["selection_list"].type == "select_mic_stack") sxcmd.token_dict["selection_list"].type = "select_mic_one" + elif sxcmd.name == "sp_star": + sxcmd.token_dict["root_dir"].type = "dir" + sxcmd.token_dict["makevstack"].type = "output" + sxcmd.token_dict["list"].type = "params_any_txt" + sxcmd.token_dict["exlist"].type = "params_any_txt" elif sxcmd.name == "sp_cter": assert(sxcmd.token_dict["selection_list"].key_base == "selection_list") assert(sxcmd.token_dict["selection_list"].type == "select_mic_stack") sxcmd.token_dict["selection_list"].type = "select_mic_one_ext" elif sxcmd.name == "sp_gpu_isac2": - sxcmd.token_dict["stack_file"].type = "data2d_stack" + sxcmd.token_dict["stack_file"].type = "bdb2d_stack" + elif sxcmd.name == "sp_header": + sxcmd.token_dict["stack"].type = "params_star" elif sxcmd.name == "sp_isac2": assert(sxcmd.token_dict["output_directory"].key_base == "output_directory") assert(sxcmd.token_dict["output_directory"].type == "output") @@ -412,6 +419,8 @@ def handle_exceptional_cases(sxcmd): assert(sxcmd.token_dict["output_directory"].key_base == "output_directory") assert(sxcmd.token_dict["output_directory"].type == "output") sxcmd.token_dict["output_directory"].type = "output_continue" + elif sxcmd.name == "sp_compute_isac_avg": + sxcmd.token_dict["stack"].type = "params_star" elif sxcmd.name == "sp_mask": sxcmd.token_dict["output_directory"].type = "dir" elif sxcmd.name == "sp_rviper": @@ -465,6 +474,7 @@ def handle_exceptional_cases(sxcmd): assert(sxcmd.token_dict["output_directory"].key_base == "output_directory") assert(sxcmd.token_dict["output_directory"].type == "output") sxcmd.token_dict["output_directory"].type = "output_continue" + sxcmd.token_dict["stack"].type = "params_star" elif sxcmd.name == "sp_meridien_alpha": assert(sxcmd.token_dict["output_directory"].key_base == "output_directory") assert(sxcmd.token_dict["output_directory"].type == "output") @@ -472,6 +482,30 @@ def handle_exceptional_cases(sxcmd): elif sxcmd.name == "sxresolution": sxcmd.token_dict["radius"].type = "int" sxcmd.token_dict["wn"].type = "int" + elif sxcmd.name == "sp_ctf_refine": + sxcmd.token_dict["path_to_input_stack"].type = "params_star" + elif sxcmd.name == "sp_polishing": + sxcmd.token_dict["post_refine_folder"].type = "dir" + sxcmd.token_dict["motioncorr_starfile"].type = "params_star" + sxcmd.token_dict["training_params"].type = "params_any_txt" + sxcmd.token_dict["relion_mpirun_executable"].type = "exe" + sxcmd.token_dict["relion_polishing_executable"].type ="exe" + sxcmd.token_dict["submission_template"].type = "submission_temp" + sxcmd.token_dict["mrc_reloc_folder"].type = "dir" + elif sxcmd.name == "sp_higher_ord_abber": + sxcmd.token_dict["post_refine_folder"].type = "dir" + sxcmd.token_dict["relion_mpirun_executable"].type = "exe" + sxcmd.token_dict["relion_ctfrefine_executable"].type ="exe" + sxcmd.token_dict["submission_template"].type = "submission_temp" + sxcmd.token_dict["mrc_reloc_folder"].type = "dir" + elif sxcmd.name == "sp_relion_3dclassifi": + sxcmd.token_dict["post_refine_folder"].type = "dir" + sxcmd.token_dict["reference_map"].type = "data3d_one" + sxcmd.token_dict["reference_mask"].type = "data3d_one" + sxcmd.token_dict["relion_mpirun_executable"].type = "exe" + sxcmd.token_dict["relion_3dclassification_executable"].type ="exe" + sxcmd.token_dict["submission_template"].type = "submission_temp" + sxcmd.token_dict["mrc_reloc_folder"].type = "dir" elif sxcmd.name == "sp_sort3d_depth": assert(sxcmd.token_dict["output_dir"].key_base == "output_dir") assert(sxcmd.token_dict["output_dir"].type == "output") @@ -522,6 +556,10 @@ def handle_exceptional_cases(sxcmd): assert(sxcmd.token_dict["fl"].key_base == "fl") assert(sxcmd.token_dict["fl"].type == "abs_freq") sxcmd.token_dict["fl"].type = "float" + elif sxcmd.subname == "isac_substack": + sxcmd.token_dict["input_star_stack_path"].type = "params_star" + elif sxcmd.subname == "restacking": + sxcmd.token_dict["input_star_stack_path"].type = "params_star" # ---------------------------------------------------------------------------------------- def remove_MoinMoinWiki_makeup(target_text): @@ -1528,10 +1566,11 @@ def create_sxcmd_subconfig_window_makevstack(): token_edit = sxgui_template.SXcmd_token(); token_edit.initialize_edit("input_bdb_stack_pattern"); token_edit.key_prefix = ""; token_edit.label = "Input BDB image stack pattern"; token_edit.help = "Specify file path pattern of stack subsets created in particle extraction using a wild card /'*/' (e.g. /'//sp_window_output_dir//*/'). The stack subsets are located in the sp_window output directory."; token_edit.group = "main"; token_edit.is_required = True; token_edit.default = ""; token_edit.type = "dir_list"; token_edit_list.append(token_edit) sxsubcmd_mpi_support = False - sxcmd_subconfig = SXsubcmd_config("Particle Stack", None, token_edit_list, sxsubcmd_mpi_support, subset_config="fullset") + sxcmd_subconfig = SXsubcmd_config("Particle Stack BDB", None, token_edit_list, sxsubcmd_mpi_support, subset_config="fullset") return sxcmd_subconfig + ### def create_sxcmd_subconfig_isacselect(): ### token_edit_list = [] ### token_edit = SXcmd_token(); token_edit.initialize_edit("isacselect"); token_edit.is_required = True; token_edit.is_locked = True; token_edit.default = True; token_edit.restore = True; token_edit_list.append(token_edit) @@ -2398,6 +2437,8 @@ def build_config_list_MoinMoinWiki(): sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/e2display.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role, exclude_list = create_exclude_list_display(), is_submittable = False)) sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/process.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_adaptive_mask3d())) sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/pipe_angular_distribution.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role)) + sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/higher_ord_abber.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role)) + sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/polishing.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role)) # -------------------------------------------------------------------------------- sxcmd_category = "sxc_sort3d" @@ -2419,6 +2460,7 @@ def build_config_list_MoinMoinWiki(): ### # post-refiner embedded sort3d_depth is removed recently. ### sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/sort3d_depth.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_sort3d_depth_postrefiner())) sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/meridien.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_meridien_final())) + sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/relion_3dclassifi.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role)) sxcmd_role = "sxr_util" sxcmd_config_list.append(SXcmd_config("../doc/MoinMoinWiki/e2display.txt", "MoinMoinWiki", sxcmd_category, sxcmd_role, exclude_list = create_exclude_list_display(), is_submittable = False)) @@ -2510,6 +2552,7 @@ def build_config_list_DokuWiki(is_dev_mode = False): sxcmd_config_list.append(SXcmd_config("../doc/cryolo_predict.txt", "DokuWiki", sxcmd_category, sxcmd_role)) sxcmd_config_list.append(SXcmd_config("../doc/window.txt", "DokuWiki", sxcmd_category, sxcmd_role)) sxcmd_config_list.append(SXcmd_config("../doc/e2bdb.txt", "DokuWiki", sxcmd_category, sxcmd_role, subconfig=create_sxcmd_subconfig_window_makevstack())) + sxcmd_config_list.append(SXcmd_config("../doc/star.txt", "DokuWiki", sxcmd_category, sxcmd_role)) sxcmd_role = "sxr_alt" sxcmd_config_list.append(SXcmd_config("../doc/cryolo_train.txt", "DokuWiki", sxcmd_category, sxcmd_role)) @@ -2627,6 +2670,9 @@ def build_config_list_DokuWiki(is_dev_mode = False): sxcmd_config_list.append( SXcmd_config("../doc/ctf_refine_stack.txt", "DokuWiki", sxcmd_category, sxcmd_role, is_submittable=True)) + sxcmd_config_list.append(SXcmd_config("../doc/higher_ord_abber.txt", "DokuWiki", sxcmd_category, sxcmd_role)) + sxcmd_config_list.append(SXcmd_config("../doc/polishing.txt", "DokuWiki", sxcmd_category, sxcmd_role)) + # -------------------------------------------------------------------------------- @@ -2652,6 +2698,7 @@ def build_config_list_DokuWiki(is_dev_mode = False): ### sxcmd_config_list.append(SXcmd_config("../doc/sort3d_depth.txt", "DokuWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_sort3d_depth_postrefiner())) sxcmd_config_list.append(SXcmd_config("../doc/process.txt", "DokuWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_postrefiner_single_vols())) sxcmd_config_list.append(SXcmd_config("../doc/meridien.txt", "DokuWiki", sxcmd_category, sxcmd_role, subconfig = create_sxcmd_subconfig_meridien_final())) + sxcmd_config_list.append(SXcmd_config("../doc/relion_3dclassifi.txt", "DokuWiki", sxcmd_category, sxcmd_role)) sxcmd_role = "sxr_util" sxcmd_config_list.append(SXcmd_config("../doc/e2display.txt", "DokuWiki", sxcmd_category, sxcmd_role, exclude_list = create_exclude_list_display(), is_submittable = False)) diff --git a/sphire/tests/test_bdb_rdwr.py b/sphire/tests/test_bdb_rdwr.py index 43fffa00a3..f945c10272 100644 --- a/sphire/tests/test_bdb_rdwr.py +++ b/sphire/tests/test_bdb_rdwr.py @@ -40,7 +40,7 @@ import unittest from numpy import allclose, array_equal from mpi import * -import sp_global_def +from sphire.libpy import sp_global_def import numpy import weakref import EMAN2db