data = data.reshape(num_pixels, num_bins) if cluster_images: data = np.transpose(data) # Execute clustering centers, _ = kmeans(data, current_num_clusters, iter=current_num_repeat, thresh=current_threshold) cluster, _ = vq(data, centers) # Fill the clusters if current_mask is not None: out_cluster = np.zeros(current_mask.shape, dtype='int') out_cluster[:] = -1 out_cluster[current_mask] = cluster cluster = out_cluster else: # Reshape the clusters to the original shape if cluster_images: pass # Nothing to be done else: cluster = cluster.reshape(indata_shape[:-1]) return cluster, centers if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_kmeans).main()
EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_rpca class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_rpca, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_rpca class name with your class name """ cl_analysis_driver(analysis_class=omsi_rpca).main()
custom_options = ['Informative Images'] else: custom_options = ['Pixel Leverage Scores', 'Pixel Rank'] dependent_options = super(omsi_cx, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_cx).main() """Test script: from omsi.dataformat.omsi_file import * from omsi.analysis.multivariate_stats.omsi_cx import * inputFile = 'test_cx.h5' f = omsi_file( inputFile , 'a' ) e = f.get_experiment(0) a = e.get_analysis(0) d = a['peak_cube'] ocxi = omsi_cx(nameKey='testCX_Images') ocxi.execute( msidata=d , rank=10, objectiveDim=omsi_cx.dimension_index['imageDim'] ) ocxp = omsi_cx(nameKey='testCX_Pixel') ocxp.execute( msidata=d , rank=10, objectiveDim=omsi_cx.dimension_index['pixelDim'] ) e.create_analysis( ocxi , flushIO=True) e.create_analysis( ocxp , flushIO=True)
other dependencies. :param analysis_object: The omsi_file_analysis object for which slicing should be performed. For most cases this is not needed here as the support for slice operations is usually a static decision based on the class type, however, in some cases additional checks may be needed (e.g., ensure that the required data is available). :returns: List of strings indicating the different available viewer options. The list should be empty if the analysis does not support qslice requests (i.e., v_qslice(...) is not available). """ custom_options = ['Tic Norm'] dependent_options = super(omsi_tic_norm, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_tic_norm).main()
EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_findpeaks_cwt class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_findpeaks_cwt, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_findpeaks_cwt class name with your class name """ cl_analysis_driver(analysis_class=omsi_findpeaks_cwt).main()
current_num_iter) # Reshape the ho matrix to be a 3D image cube ho_matrix = ho_matrix.transpose() if current_mask is not None: out_ho = np.zeros(output_shape, dtype=ho_matrix.dtype) out_ho[current_mask, :] = ho_matrix ho_matrix = out_ho else: ho_matrix = ho_matrix.reshape(output_shape) return wo_matrix, ho_matrix if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_nmf).main() # def main(argv=None): # """Then main function""" # # import sys # from sys import argv, exit # import matplotlib.pyplot as plt # import matplotlib.gridspec as gridspec # from math import log # from omsi.dataformat.omsi_file import omsi_file # # if argv is None: # argv = sys.argv #
EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_mz_upsample class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_mz_upsample, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_mz_upsample class name with your class name """ cl_analysis_driver(analysis_class=omsi_mz_upsample).main()
""" Simple helper tool to run an analysis. This is essentially just a short-cut to the omsi/workflow/analysis_driver/omsi_cl_diver module """ from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver if __name__ == "__main__": # Create a command-line driver and call main to run the analysis cl_analysis_driver(analysis_class=None, add_analysis_class_arg=True, add_output_arg=True, add_log_level_arg=True).main()
EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the analysis_template class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(analysis_template, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the analysis_template class name with your class name """ cl_analysis_driver(analysis_class=analysis_template).main()
print time_str sys.stdout.flush() # Initialize the hit_table if necessary if hit_table is None: # If our compound database does not contain any related compounds then just finish if current_hits.shape[0] == 0: # Initialize the results as empty and finish as there is nothing to do hit_table = np.zeros(shape=(pixel_index.shape[0], 0), dtype=MIDAS.scoring_C.HIT_TABLE_DTYPE) # FIXME the number of hits may be different for different spectra if we have varying precursor m/z continue # If our compound database contains at least one relevant compound then check all spectra else: # Create the data structure to store all results hit_table = np.zeros(shape=(pixel_index.shape[0], current_hits.shape[0]), dtype=current_hits.dtype) # FIXME the number of hits may be different for different spectra if we have varying precursor m/z # Save the hits for the current pixel hit_table[current_index] = current_hits if hit_table is None: hit_table = np.zeros(shape=(pixel_index.shape[0], 0), dtype=MIDAS.scoring_C.HIT_TABLE_DTYPE) # Return the hit_table and the index of the pixel each hit_table applies to return hit_table, pixel_index if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_score_midas).main()
analysis_object): """ Get a list of strings describing the different default viewer options for the analysis for qslice. The default implementation tries to take care of handling the spectra retrieval for all the depencies but can naturally not decide how the qspectrum should be handled by a derived class. However, this implementation is often called at the end of custom implementations to also allow access to data from other dependencies. :param analysis_object: The omsi_file_analysis object for which slicing should be performed. For most cases this is not needed here as the support for slice operations is usually a static decision based on the class type, however, in some cases additional checks may be needed (e.g., ensure that the required data is available). :returns: List of strings indicating the different available viewer options. The list should be empty if the analysis does not support qslice requests (i.e., v_qslice(...) is not available). """ custom_options = ['Rebinned Images'] dependent_options = super(omsi_mz_rebin, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_mz_rebin).main()
For most cases this is not needed here as the support for slice operations is usually a static decision based on the class type, however, in some cases additional checks may be needed (e.g., ensure that the required data is available). :returns: List of strings indicating the different available viewer options. The list should be empty if the analysis does not support qslice requests (i.e., v_qslice(...) is not available). """ """ EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_mask_by_cluster class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_mask_by_cluster, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_mask_by_cluster).main()
For most cases this is not needed here as the support for slice operations is usually a static decision based on the class type, however, in some cases additional checks may be needed (e.g., ensure that the required data is available). :returns: List of strings indicating the different available viewer options. The list should be empty if the analysis does not support qslice requests (i.e., v_qslice(...) is not available). """ """ EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_filter_by_mask class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_filter_by_mask, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_filter_by_mask).main()
# We here convert the single scalars to 1D numpy arrays to ensure consistency. The data write function can # handle also a large range of python built_in types by converting them to numpy for storage in HDF5 but # to ensure a consistent behavior we convert the values directly here # Clean up the biggest chunks of memory we allocated when we potentially loaded the data from file del data del processed_msidata del flat_data # Save the analysis data to the __data_list so that the data can be # saved automatically by the omsi HDF5 file API return peak_cube, mz_peaks if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_findpeaks_global).main() # def main(argv=None): # """Then main function""" # # import sys # from omsi.dataformat.omsi_file.main_file import omsi_file # import matplotlib.pyplot as plt # import matplotlib.gridspec as gridspec # import numpy as np # # if argv is None: # argv = sys.argv # # # Check for correct usage
pactolus_results=hit_matrix[current_index], table_file=file_lookup_table, original_db=metabolite_database)) for score_index in non_zero_scores: pixel_index.append(fpl_peak_arrayindex[spectrum_index, 0:2]) score.append(current_hit_table['score'][score_index]) id_data.append(current_hit_table['id'][score_index]) name.append(current_hit_table['name'][score_index]) mass.append(current_hit_table['mass'][score_index]) n_peaks.append(current_hit_table['n_peaks'][score_index]) n_match.append(current_hit_table['n_match'][score_index]) else: pixel_index = fpl_peak_arrayindex[spectrum_indexes, 0:2] score = np.asarray(hit_matrix) # Return the hit_table and the index of the pixel each hit_table applies to print "rank : " + str(mpi_helper.get_rank()) + " : scores " + str(score) sys.stdout.flush() return np.asarray(pixel_index), \ np.asarray(score), \ np.asarray(id_data), \ np.asarray(name), \ np.asarray(mass), \ np.asarray(n_peaks), \ np.asarray(n_match) if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_score_pactolus).main()
Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_xy_resize class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_xy_resize, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_xy_resize class name with your class name """ cl_analysis_driver(analysis_class=omsi_xy_resize).main()
pixel_index.append(fpl_peak_arrayindex[spectrum_index, 0:2]) score.append(current_hit_table['score'][score_index]) id_data.append(current_hit_table['id'][score_index]) name.append(current_hit_table['name'][score_index]) mass.append(current_hit_table['mass'][score_index]) n_peaks.append( current_hit_table['n_peaks'][score_index]) n_match.append( current_hit_table['n_match'][score_index]) else: pixel_index = fpl_peak_arrayindex[spectrum_indexes, 0:2] score = np.asarray(hit_matrix) # Return the hit_table and the index of the pixel each hit_table applies to print "rank : " + str( mpi_helper.get_rank()) + " : scores " + str(score) sys.stdout.flush() return np.asarray(pixel_index), \ np.asarray(score), \ np.asarray(id_data), \ np.asarray(name), \ np.asarray(mass), \ np.asarray(n_peaks), \ np.asarray(n_match) if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_score_pactolus).main()
EDIT_ME Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_xy_smooth class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_xy_smooth, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_xy_smooth class name with your class name """ cl_analysis_driver(analysis_class=omsi_xy_smooth).main()
Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_mz_upsample class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_mz_upsample, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_mz_upsample class name with your class name """ cl_analysis_driver(analysis_class=omsi_mz_upsample).main()
@classmethod def v_qslice_viewer_options(cls, analysis_object): """ Get a list of strings describing the different default viewer options for the analysis for qslice. The default implementation tries to take care of handling the spectra retrieval for all the depencies but can naturally not decide how the qspectrum should be handled by a derived class. However, this implementation is often called at the end of custom implementations to also allow access to data from other dependencies. :param analysis_object: The omsi_file_analysis object for which slicing should be performed. For most cases this is not needed here as the support for slice operations is usually a static decision based on the class type, however, in some cases additional checks may be needed (e.g., ensure that the required data is available). :returns: List of strings indicating the different available viewer options. The list should be empty if the analysis does not support qslice requests (i.e., v_qslice(...) is not available). """ custom_options = ['Rebinned Images'] dependent_options = super(omsi_mz_rebin, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver cl_analysis_driver(analysis_class=omsi_mz_rebin).main()
Define a list of custom viewer_options are supported. E.g: custom_options = ['Peak cube'] """ custom_options = [] """ EDIT_ME Change the omsi_rpca class-name to your class. If you did a replace all, then this should be done already. """ dependent_options = super(omsi_rpca, cls).v_qslice_viewer_options(analysis_object) slice_viewer_options = custom_options + dependent_options return slice_viewer_options ############################################################ # 3) Making your analysis self-sufficient (Recommended) # ############################################################ if __name__ == "__main__": from omsi.workflow.driver.cl_analysis_driver import cl_analysis_driver """ EDIT_ME Simply replace the omsi_rpca class name with your class name """ cl_analysis_driver(analysis_class=omsi_rpca).main()