def error_analysis(self): """Perform an error analysis of the peak intensities for each field strength separately.""" # Printout. section(file=sys.stdout, text="Error analysis", prespace=2) # Check if intensity errors have already been calculated by the user. precalc = True for spin in spin_loop(skip_desel=True): # No structure. if not hasattr(spin, 'peak_intensity_err'): precalc = False break # Determine if a spectrum ID is missing from the list. for id in cdp.spectrum_ids: if id not in spin.peak_intensity_err: precalc = False break # Skip. if precalc: print("Skipping the error analysis as it has already been performed.") return # Perform the error analysis. self.interpreter.spectrum.error_analysis_per_field()
def error_analysis(self): """Perform an error analysis of the peak intensities for each field strength separately.""" # Printout. section(file=sys.stdout, text="Error analysis", prespace=2) # Check if intensity errors have already been calculated by the user. precalc = True for spin in spin_loop(skip_desel=True): # No structure. if not hasattr(spin, 'peak_intensity_err'): precalc = False break # Determine if a spectrum ID is missing from the list. for id in cdp.spectrum_ids: if id not in spin.peak_intensity_err: precalc = False break # Skip. if precalc: print( "Skipping the error analysis as it has already been performed." ) return # Perform the error analysis. self.interpreter.spectrum.error_analysis_per_field()
def error_analysis_per_field(): """Perform an error analysis of the peak intensities for each field strength separately.""" # Printout. section(file=sys.stdout, text="Automatic Error analysis per field strength", prespace=2) # Handle missing frequency data. frqs = [None] if hasattr(cdp, 'spectrometer_frq_list'): frqs = cdp.spectrometer_frq_list # Loop over the spectrometer frequencies. for frq in frqs: # Generate a list of spectrum IDs matching the frequency. ids = [] for id in cdp.spectrum_ids: # Check that the spectrometer frequency matches. match_frq = True if frq != None and cdp.spectrometer_frq[id] != frq: match_frq = False # Add the ID. if match_frq: ids.append(id) # Run the error analysis on the subset. print("For field strength %.8f MHz, subset ids for spectrum.error_analysis is: %s" % (frq/1e6, ids)) error_analysis(subset=ids)
def check_numpy_less_1_8_and_numerical_model(self): """Check for numerical model using numpy version under 1.8. This will result in slow "for loop" calculation through data, making the analysis 5-6 times slower.""" # Some warning for the user if the pure numeric solution is selected. if float(version.version[:3]) < 1.8: # Store which models are in numeric. models = [] # Loop through models. for model in self.models: if model in MODEL_LIST_NUMERIC: models.append(model) # Write system message if numerical models is present and numpy version is below 1.8. if len(models) > 0: # Printout. section(file=sys.stdout, text="Numpy version checking for numerical models.", prespace=2) warn( RelaxWarning( "Your version of numpy is %s, and below the recommended version of 1.8 for numerical models." % (version.version))) warn( RelaxWarning( "Please consider upgrading your numpy version to 1.8.") ) # Loop over models. for model in models: warn( RelaxWarning( "This could make the numerical analysis with model '%s', 5 to 6 times slower." % (model)))
def check_vars(self): """Check that the user has set the variables correctly.""" # Printout. section(file=sys.stdout, text="Variable checking", prespace=2) # The pipe name. if not has_pipe(self.pipe_name): raise RelaxNoPipeError(self.pipe_name) # Check the model selection. allowed = ['AIC', 'AICc', 'BIC'] if self.modsel not in allowed: raise RelaxError("The model selection technique '%s' is not in the allowed list of %s." % (self.modsel, allowed)) # Some warning for the user if the pure numeric solution is selected. if self.numeric_only: # Loop over all models. for model in self.models: # Skip the models used for nesting. if model in [MODEL_CR72, MODEL_MMQ_CR72, MODEL_MP05]: continue # Warnings for all other analytic models. if model in MODEL_LIST_ANALYTIC: warn(RelaxWarning("The analytic model '%s' will be optimised but will not be used in any way in this numeric model only auto-analysis." % model)) # Printout. print("The dispersion auto-analysis variables are OK.")
def optimise_rigid(self): """Optimise the rigid frame order model. The Sobol' integration is not used here, so the algorithm is different to the other frame order models. """ # The model. model = 'rigid' title = model[0].upper() + model[1:] # Print out. section(file=sys.stdout, text="%s frame order model"%title, prespace=5) # The data pipe name. self.pipe_name_dict[model] = '%s - %s' % (title, self.pipe_bundle) self.pipe_name_list.append(self.pipe_name_dict[model]) # The results file already exists, so read its contents instead. if self.read_results(model=model, pipe_name=self.pipe_name_dict[model]): # The PDB representation of the model (in case this was not completed correctly). self.interpreter.frame_order.pdb_model(dir=self.results_dir+model, force=True) # Nothing more to do. return # Create the data pipe using the full data set, and switch to it. self.interpreter.pipe.copy(self.data_pipe_full, self.pipe_name_dict[model], bundle_to=self.pipe_bundle) self.interpreter.pipe.switch(self.pipe_name_dict[model]) # Select the Frame Order model. self.interpreter.frame_order.select_model(model=model) # Split grid search if translation is active. if cdp.ave_pos_translation: # Printout. print("\n\nTranslation active - splitting the grid search and iterating.") # Loop twice. for i in range(2): # First optimise the rotation. self.interpreter.grid_search(inc=[None, None, None, self.grid_inc_rigid, self.grid_inc_rigid, self.grid_inc_rigid], constraints=False) # Then the translation. self.interpreter.grid_search(inc=[self.grid_inc_rigid, self.grid_inc_rigid, self.grid_inc_rigid, None, None, None], constraints=False) # Standard grid search. else: self.interpreter.grid_search(inc=self.grid_inc_rigid, constraints=False) # Minimise. self.interpreter.minimise(self.min_algor, constraints=False) # Results printout. self.print_results() # Save the results. self.interpreter.results.write(dir=self.results_dir+model, force=True) # The PDB representation of the model. self.interpreter.frame_order.pdb_model(dir=self.results_dir+model, force=True)
def error_analysis_per_field(): """Perform an error analysis of the peak intensities for each field strength separately.""" # Printout. section(file=sys.stdout, text="Automatic Error analysis per field strength", prespace=2) # Handle missing frequency data. frqs = [None] if hasattr(cdp, 'spectrometer_frq_list'): frqs = cdp.spectrometer_frq_list # Loop over the spectrometer frequencies. for frq in frqs: # Generate a list of spectrum IDs matching the frequency. ids = [] for id in cdp.spectrum_ids: # Check that the spectrometer frequency matches. match_frq = True if frq != None and cdp.spectrometer_frq[id] != frq: match_frq = False # Add the ID. if match_frq: ids.append(id) # Run the error analysis on the subset. print( "For field strength %.8f MHz, subset ids for spectrum.error_analysis is: %s" % (frq / 1e6, ids)) error_analysis(subset=ids)
def summary(self): """Print out a summary of the relax test suite.""" # Title. title(file=sys.stdout, text="Summary of the relax test suite") # The skipped tests. self.summary_skipped() # Subtitle. section(file=sys.stdout, text="Synopsis") # System/functional test summary. if hasattr(self, 'system_result'): summary_line("System/functional tests", self.system_result) # Unit test summary. if hasattr(self, 'unit_result'): summary_line("Unit tests", self.unit_result) # GUI test summary. if hasattr(self, 'gui_result'): summary_line("GUI tests", self.gui_result) # Synopsis. if hasattr(self, 'system_result') and hasattr(self, 'unit_result') and hasattr(self, 'gui_result'): if self.gui_result == "skip": status = self.system_result and self.unit_result else: status = self.system_result and self.unit_result and self.gui_result summary_line("Synopsis", status) # End. print('\n\n')
def check_vars(self): """Check that the user has set the variables correctly.""" # Printout. section(file=sys.stdout, text="Variable checking", prespace=2) # The pipe name. if not has_pipe(self.pipe_name): raise RelaxNoPipeError(self.pipe_name) # Check the model selection. allowed = ['AIC', 'AICc', 'BIC'] if self.modsel not in allowed: raise RelaxError( "The model selection technique '%s' is not in the allowed list of %s." % (self.modsel, allowed)) # Some warning for the user if the pure numeric solution is selected. if self.numeric_only: # Loop over all models. for model in self.models: # Skip the models used for nesting. if model in MODEL_LIST_NEST: continue # Warnings for all other analytic models. if model in MODEL_LIST_ANALYTIC: warn( RelaxWarning( "The analytic model '%s' will be optimised but will not be used in any way in this numeric model only auto-analysis." % model)) # Printout. print("The dispersion auto-analysis variables are OK.")
def summary(self): """Print out a summary of the relax test suite.""" # Title. title(file=sys.stdout, text="Summary of the relax test suite") # The skipped tests. if status.skip_blacklisted_tests: self.summary_skipped() # Subtitle. section(file=sys.stdout, text="Synopsis") # System/functional test summary. if hasattr(self, 'system_result'): summary_line("System/functional tests", self.system_result, width=status.text_width) # Unit test summary. if hasattr(self, 'unit_result'): summary_line("Unit tests", self.unit_result, width=status.text_width) # GUI test summary. if hasattr(self, 'gui_result'): summary_line("GUI tests", self.gui_result, width=status.text_width) # Verification test summary. if hasattr(self, 'verification_result'): summary_line("Software verification tests", self.verification_result, width=status.text_width) # Synopsis. if hasattr(self, 'system_result') and hasattr( self, 'unit_result') and hasattr(self, 'gui_result') and hasattr( self, 'verification_result'): if self.gui_result == "skip": test_status = self.system_result and self.unit_result and self.verification_result else: test_status = self.system_result and self.unit_result and self.gui_result and self.verification_result summary_line("Synopsis", test_status, width=status.text_width) # End. print('\n\n')
def optimise(self, model=None): """Optimise the model, taking model nesting into account. @keyword model: The model to be optimised. @type model: str """ # Printout. section(file=sys.stdout, text="Optimisation", prespace=2) # Deselect insignificant spins. if model not in ['R2eff', 'No Rex']: self.interpreter.relax_disp.insignificance(level=self.insignificance) # Use pre-run results as the optimisation starting point. if self.pre_run_dir: self.pre_run_parameters(model=model) # Otherwise use the normal nesting check and grid search if not nested. else: # Nested model simplification. nested = self.nesting(model=model) # Grid search. if not nested: self.interpreter.grid_search(inc=self.grid_inc) # Minimise. self.interpreter.minimise('simplex', func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=True) # Model elimination. if self.eliminate: self.interpreter.eliminate() # Monte Carlo simulations. if self.mc_sim_all_models or len(self.models) < 2 or model == 'R2eff': self.interpreter.monte_carlo.setup(number=self.mc_sim_num) self.interpreter.monte_carlo.create_data() self.interpreter.monte_carlo.initial_values() self.interpreter.minimise('simplex', func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=True) if self.eliminate: self.interpreter.eliminate() self.interpreter.monte_carlo.error_analysis()
def error_analysis(self): """Perform an error analysis of the peak intensities for each field strength separately.""" # Printout. section(file=sys.stdout, text="Error analysis", prespace=2) # Check if intensity errors have already been calculated by the user. precalc = True for spin in spin_loop(skip_desel=True): # No structure. if not hasattr(spin, 'intensity_err'): precalc = False break # Determine if a spectrum ID is missing from the list. for id in cdp.spectrum_ids: if id not in spin.intensity_err: precalc = False break # Skip. if precalc: print("Skipping the error analysis as it has already been performed.") return # Loop over the spectrometer frequencies. for frq in loop_frq(): # Generate a list of spectrum IDs matching the frequency. ids = [] for id in cdp.spectrum_ids: # Check that the spectrometer frequency matches. match_frq = True if frq != None and cdp.spectrometer_frq[id] != frq: match_frq = False # Add the ID. if match_frq: ids.append(id) # Run the error analysis on the subset. self.interpreter.spectrum.error_analysis(subset=ids)
def test_section(self): """Test of the lib.text.sectioning.section() function.""" # Write out the section. file = DummyFileObject() section(file=file, text='Test section') # Read the results. lines = file.readlines() print("Formatted section lines: %s" % lines) # Check the title. real_lines = [ '\n', '\n', 'Test section\n', '============\n', '\n', ] self.assertEqual(len(lines), len(real_lines)) for i in range(len(lines)): self.assertEqual(lines[i], real_lines[i])
def check_numpy_less_1_8_and_numerical_model(self): """Check for numerical model using numpy version under 1.8. This will result in slow "for loop" calculation through data, making the analysis 5-6 times slower.""" # Some warning for the user if the pure numeric solution is selected. if float(version.version[:3]) < 1.8: # Store which models are in numeric. models = [] # Loop through models. for model in self.models: if model in MODEL_LIST_NUMERIC: models.append(model) # Write system message if numerical models is present and numpy version is below 1.8. if len(models) > 0: # Printout. section(file=sys.stdout, text="Numpy version checking for numerical models.", prespace=2) warn(RelaxWarning("Your version of numpy is %s, and below the recommended version of 1.8 for numerical models." % (version.version))) warn(RelaxWarning("Please consider upgrading your numpy version to 1.8.")) # Loop over models. for model in models: warn(RelaxWarning("This could make the numerical analysis with model '%s', 5 to 6 times slower." % (model)))
def signal_noise_ratio(verbose=True): """Calculate the signal to noise ratio per spin. @keyword verbose: A flag which if True will print additional information out. @type verbose: bool """ # Tests. check_pipe() check_mol_res_spin_data() # Test if spectra have been loaded. if not hasattr(cdp, 'spectrum_ids'): raise RelaxError("No spectra have been loaded.") # Possible print. if verbose: print("\nThe following signal to noise ratios has been calculated:\n") # Set the spin specific signal to noise ratio. for spin, spin_id in spin_loop(return_id=True): # Skip deselected spins. if not spin.select: continue # Skip spins missing intensity data. if not hasattr(spin, 'peak_intensity'): continue # Test if error analysis has been performed. if not hasattr(spin, 'peak_intensity_err'): raise RelaxError( "Intensity error analysis has not been performed. Please see spectrum.error_analysis()." ) # If necessary, create the dictionary. if not hasattr(spin, 'sn_ratio'): spin.sn_ratio = {} # Loop over the ID. ids = [] for id in spin.peak_intensity: # Append the ID to the list. ids.append(id) # Calculate the sn_ratio. pint = float(spin.peak_intensity[id]) pint_err = float(spin.peak_intensity_err[id]) sn_ratio = pint / pint_err # Assign the sn_ratio. spin.sn_ratio[id] = sn_ratio # Sort the ids alphanumeric. ids = sort_filenames(filenames=ids, rev=False) # Collect the data under sorted ids. data_i = [] for id in ids: # Get the values. pint = spin.peak_intensity[id] pint_err = spin.peak_intensity_err[id] sn_ratio = spin.sn_ratio[id] # Store the data. data_i.append([id, repr(pint), repr(pint_err), repr(sn_ratio)]) if verbose: section(file=sys.stdout, text="Signal to noise ratio for spin ID '%s'" % spin_id, prespace=1) write_data(out=sys.stdout, headings=["Spectrum ID", "Signal", "Noise", "S/N"], data=data_i)
def nested_models(self): """Protocol for the nested optimisation of the frame order models.""" # First optimise the rigid model using all data. self.optimise_rigid() # Iteratively optimise the frame order models. for model in self.models: # Skip the already optimised rigid model. if model == 'rigid': continue # The model title. title = model[0].upper() + model[1:] # Printout. section(file=sys.stdout, text="%s frame order model"%title, prespace=5) # The data pipe name. self.pipe_name_dict[model] = '%s - %s' % (title, self.pipe_bundle) self.pipe_name_list.append(self.pipe_name_dict[model]) # The results file already exists, so read its contents instead. if self.read_results(model=model, pipe_name=self.pipe_name_dict[model]): # Re-perform model elimination just in case. self.interpreter.eliminate() # The PDB representation of the model and visualisation script (in case this was not completed correctly). self.visualisation(model=model) # Skip to the next model. continue # Create the data pipe using the full data set, and switch to it. self.interpreter.pipe.copy(self.data_pipe_subset, self.pipe_name_dict[model], bundle_to=self.pipe_bundle) self.interpreter.pipe.switch(self.pipe_name_dict[model]) # Select the Frame Order model. self.interpreter.frame_order.select_model(model=model) # Copy nested parameters. self.nested_params(model) # The optimisation settings. self.interpreter.frame_order.num_int_pts(num=self.num_int_pts_grid) self.interpreter.frame_order.quad_int(flag=False) # Grid search. incs = self.custom_grid_incs(model) self.interpreter.grid_search(inc=incs, constraints=False) # Minimise (for the PCS data subset and full RDC set). for i in range(len(self.num_int_pts_subset)): self.interpreter.frame_order.num_int_pts(num=self.num_int_pts_subset[i]) self.interpreter.minimise(self.min_algor, func_tol=self.func_tol_subset[i], constraints=False) # Copy the PCS data. self.interpreter.pcs.copy(pipe_from=self.data_pipe_full, pipe_to=self.pipe_name_dict[model]) # Minimise (for the full data set). for i in range(len(self.num_int_pts_full)): self.interpreter.frame_order.num_int_pts(num=self.num_int_pts_full[i]) self.interpreter.minimise(self.min_algor, func_tol=self.func_tol_full[i], constraints=False) # Results printout. self.print_results() # Model elimination. self.interpreter.eliminate() # Save the results. self.interpreter.results.write(dir=self.results_dir+model, force=True) # The PDB representation of the model and visualisation script. self.visualisation(model=model)
def sn_ratio_deselection(ratio=10.0, operation='<', all_sn=False, select=False, verbose=True): """Use user function deselect.spin on spins with signal to noise ratio higher or lower than ratio. The operation determines the selection operation. @keyword ratio: The ratio to compare to. @type ratio: float @keyword operation: The comparison operation by which to select the spins. Of the operation(sn_ratio, ratio), where operation can either be: '<', '<=', '>', '>=', '==', '!='. @type operation: str @keyword all_sn: A flag specifying if all the signal to noise ratios per spin should match the comparison operator, of if just a single comparison match is enough. @type all_sn: bool @keyword select: A flag specifying if the user function select.spin should be used instead. @type select: bool @keyword verbose: A flag which if True will print additional information out. @type verbose: bool """ # Tests. check_pipe() check_mol_res_spin_data() # Test if spectra have been loaded. if not hasattr(cdp, 'spectrum_ids'): raise RelaxError("No spectra have been loaded.") # Assign the comparison operator. # "'<' : strictly less than" if operation == '<': op = operator.lt # "'<=' : less than or equal" elif operation == '<=': op = operator.le # "'>' : strictly greater than" elif operation == '>': op = operator.gt # "'>=' : greater than or equal" elif operation == '>=': op = operator.ge # "'==' : equal" elif operation == '==': op = operator.eq # "'!=' : not equal", elif operation == '!=': op = operator.ne # If not assigned, raise error. else: raise RelaxError( "The compare operation does not belong to the allowed list of methods: ['<', '<=', '>', '>=', '==', '!=']" ) # Assign text for print out. if all_sn: text_all_sn = "all" else: text_all_sn = "any" if select: text_sel = "selected" sel_func = sel_spin else: text_sel = "deselected" sel_func = desel_spin # Print section(file=sys.stdout, text="Signal to noise ratio comparison selection", prespace=1, postspace=0) print("For the comparion test: S/N %s %1.1f" % (operation, ratio)) # Loop over the spins. spin_ids = [] for spin, spin_id in spin_loop(return_id=True): # Skip spins missing sn_ratio. if not hasattr(spin, 'sn_ratio'): # Skip warning for deselected spins. if spin.select: warn( RelaxWarning( "Spin '%s' does not contain Signal to Noise calculations. Perform the user function 'spectrum.sn_ratio'. This spin is skipped." % spin_id)) continue # Loop over the ID, collect and sort. ids = [] for id in spin.peak_intensity: # Append the ID to the list. ids.append(id) # Sort the ids alphanumeric. ids = sort_filenames(filenames=ids, rev=False) # Loop over the sorted ids. sn_val = [] for id in ids: # Append the Signal to Noise in the list. sn_val.append(spin.sn_ratio[id]) # Convert the list to array. sn_val = asarray(sn_val) # Make the comparison for the whole array. test_arr = op(sn_val, ratio) # Determine how the test should evaluate. if all_sn: test = test_arr.all() else: test = test_arr.any() # Make an numpy array for the ids, an extract id which failed the test. ids_arr = asarray(ids) ids_test_arr = ids_arr[test_arr] # Make inversion of bool test_arr_inv = test_arr == False ids_test_arr_inv = ids_arr[test_arr_inv] # print if verbose: subsection( file=sys.stdout, text="Signal to noise ratio comparison for spin ID '%s'" % spin_id, prespace=1, postspace=0) print("Following spectra ID evaluated to True: %s" % ids_test_arr) print("Following spectra ID evaluated to False: %s" % ids_test_arr_inv) print( "'%s' comparisons have been used for evaluation, which evaluated to: %s" % (text_all_sn, test)) if test: print("The spin ID '%s' is %s" % (spin_id, text_sel)) else: print("The spin ID '%s' is skipped" % spin_id) # If the test evaluates to True, then do selection action. if test: # Select/Deselect the spin. sel_func(spin_id=spin_id) # Assign spin_id to list, for printing. spin_ids.append(spin_id) # Make summary if verbose: if len(spin_ids) > 0: subsection( file=sys.stdout, text= "For all of the S/N comparion test, the following spin ID's was %s" % text_sel, prespace=1, postspace=0) print(spin_ids)
def summary_skipped(self): """Print out information about skipped tests.""" # Counts. system_count = {} unit_count = {} gui_count = {} verification_count = {} for i in range(len(status.skipped_tests)): # Alias. test = status.skipped_tests[i] # Skip all skipped tests whereby the module is set to None to indicate that the test skipping should not be reported. if test[1] == None: continue # Initialise in needed. if not test[1] in system_count: system_count[test[1]] = 0 unit_count[test[1]] = 0 gui_count[test[1]] = 0 verification_count[test[1]] = 0 # A system test. if test[2] == 'system': system_count[test[1]] += 1 # A unit test. if test[2] == 'unit': unit_count[test[1]] += 1 # A GUI test. if test[2] == 'gui': gui_count[test[1]] += 1 # A verification test. if test[2] == 'verification': verification_count[test[1]] += 1 # The missing modules. missing_modules = sorted(system_count.keys()) section(file=sys.stdout, text="Optional packages/modules") # Nothing missing. if not missing_modules: # Except for the wx module! if not dep_check.wx_module and hasattr(self, 'gui_result'): print("All GUI tests skipped due to the missing wxPython module, no other tests skipped due to missing modules.\n") # Normal printout. else: print("No tests skipped due to missing modules.\n") # The skip the table. return # Header. print("Tests skipped due to missing optional packages/modules/software:\n") header = "%-33s" % "Module/package/software" if len(system_count): header = "%s %20s" % (header, "System test count") if len(unit_count): header = "%s %20s" % (header, "Unit test count") if len(gui_count): header = "%s %20s" % (header, "GUI test count") if len(verification_count): header = "%s %20s" % (header, "Verification test count") print('-'*len(header)) print(header) print('-'*len(header)) # The table. for module in missing_modules: text = "%-33s" % module if len(system_count): text = "%s %20s" % (text, system_count[module]) if len(unit_count): text = "%s %20s" % (text, unit_count[module]) if len(gui_count): text = "%s %20s" % (text, gui_count[module]) if len(verification_count): text = "%s %20s" % (text, verification_count[module]) print(text) # End the table. print('-'*len(header)) print("\n")
def sn_ratio_deselection(ratio=10.0, operation='<', all_sn=False, select=False, verbose=True): """Use user function deselect.spin on spins with signal to noise ratio higher or lower than ratio. The operation determines the selection operation. @keyword ratio: The ratio to compare to. @type ratio: float @keyword operation: The comparison operation by which to select the spins. Of the operation(sn_ratio, ratio), where operation can either be: '<', '<=', '>', '>=', '==', '!='. @type operation: str @keyword all_sn: A flag specifying if all the signal to noise ratios per spin should match the comparison operator, of if just a single comparison match is enough. @type all_sn: bool @keyword select: A flag specifying if the user function select.spin should be used instead. @type select: bool @keyword verbose: A flag which if True will print additional information out. @type verbose: bool """ # Tests. check_pipe() check_mol_res_spin_data() # Test if spectra have been loaded. if not hasattr(cdp, 'spectrum_ids'): raise RelaxError("No spectra have been loaded.") # Assign the comparison operator. # "'<' : strictly less than" if operation == '<': op = operator.lt # "'<=' : less than or equal" elif operation == '<=': op = operator.le # "'>' : strictly greater than" elif operation == '>': op = operator.gt # "'>=' : greater than or equal" elif operation == '>=': op = operator.ge # "'==' : equal" elif operation == '==': op = operator.eq # "'!=' : not equal", elif operation == '!=': op = operator.ne # If not assigned, raise error. else: raise RelaxError("The compare operation does not belong to the allowed list of methods: ['<', '<=', '>', '>=', '==', '!=']") # Assign text for print out. if all_sn: text_all_sn = "all" else: text_all_sn = "any" if select: text_sel = "selected" sel_func = sel_spin else: text_sel = "deselected" sel_func = desel_spin # Print section(file=sys.stdout, text="Signal to noise ratio comparison selection", prespace=1, postspace=0) print("For the comparion test: S/N %s %1.1f"%(operation, ratio)) # Loop over the spins. spin_ids = [] for spin, spin_id in spin_loop(return_id=True): # Skip spins missing sn_ratio. if not hasattr(spin, 'sn_ratio'): # Skip warning for deselected spins. if spin.select: warn(RelaxWarning("Spin '%s' does not contain Signal to Noise calculations. Perform the user function 'spectrum.sn_ratio'. This spin is skipped." % spin_id)) continue # Loop over the ID, collect and sort. ids = [] for id in spin.peak_intensity: # Append the ID to the list. ids.append(id) # Sort the ids alphanumeric. ids = sort_filenames(filenames=ids, rev=False) # Loop over the sorted ids. sn_val = [] for id in ids: # Append the Signal to Noise in the list. sn_val.append(spin.sn_ratio[id]) # Convert the list to array. sn_val = asarray(sn_val) # Make the comparison for the whole array. test_arr = op(sn_val, ratio) # Determine how the test should evaluate. if all_sn: test = test_arr.all() else: test = test_arr.any() # Make an numpy array for the ids, an extract id which failed the test. ids_arr = asarray(ids) ids_test_arr = ids_arr[test_arr] # Make inversion of bool test_arr_inv = test_arr == False ids_test_arr_inv = ids_arr[test_arr_inv] # print if verbose: subsection(file=sys.stdout, text="Signal to noise ratio comparison for spin ID '%s'"%spin_id, prespace=1, postspace=0) print("Following spectra ID evaluated to True: %s"%ids_test_arr) print("Following spectra ID evaluated to False: %s"%ids_test_arr_inv) print("'%s' comparisons have been used for evaluation, which evaluated to: %s"%(text_all_sn, test)) if test: print("The spin ID '%s' is %s"%(spin_id, text_sel)) else: print("The spin ID '%s' is skipped"%spin_id) # If the test evaluates to True, then do selection action. if test: # Select/Deselect the spin. sel_func(spin_id=spin_id) # Assign spin_id to list, for printing. spin_ids.append(spin_id) # Make summary if verbose: if len(spin_ids) > 0: subsection(file=sys.stdout, text="For all of the S/N comparion test, the following spin ID's was %s"%text_sel, prespace=1, postspace=0) print(spin_ids)
def signal_noise_ratio(verbose=True): """Calculate the signal to noise ratio per spin. @keyword verbose: A flag which if True will print additional information out. @type verbose: bool """ # Tests. check_pipe() check_mol_res_spin_data() # Test if spectra have been loaded. if not hasattr(cdp, 'spectrum_ids'): raise RelaxError("No spectra have been loaded.") # Possible print. if verbose: print("\nThe following signal to noise ratios has been calculated:\n") # Set the spin specific signal to noise ratio. for spin, spin_id in spin_loop(return_id=True): # Skip deselected spins. if not spin.select: continue # Skip spins missing intensity data. if not hasattr(spin, 'peak_intensity'): continue # Test if error analysis has been performed. if not hasattr(spin, 'peak_intensity_err'): raise RelaxError("Intensity error analysis has not been performed. Please see spectrum.error_analysis().") # If necessary, create the dictionary. if not hasattr(spin, 'sn_ratio'): spin.sn_ratio = {} # Loop over the ID. ids = [] for id in spin.peak_intensity: # Append the ID to the list. ids.append(id) # Calculate the sn_ratio. pint = float(spin.peak_intensity[id]) pint_err = float(spin.peak_intensity_err[id]) sn_ratio = pint / pint_err # Assign the sn_ratio. spin.sn_ratio[id] = sn_ratio # Sort the ids alphanumeric. ids = sort_filenames(filenames=ids, rev=False) # Collect the data under sorted ids. data_i = [] for id in ids: # Get the values. pint = spin.peak_intensity[id] pint_err = spin.peak_intensity_err[id] sn_ratio = spin.sn_ratio[id] # Store the data. data_i.append([id, repr(pint), repr(pint_err), repr(sn_ratio)]) if verbose: section(file=sys.stdout, text="Signal to noise ratio for spin ID '%s'"%spin_id, prespace=1) write_data(out=sys.stdout, headings=["Spectrum ID", "Signal", "Noise", "S/N"], data=data_i)
def write_results(self, path=None, model=None): """Create a set of results, text and Grace files for the current data pipe. @keyword path: The directory to place the files into. @type path: str """ # Printout. section(file=sys.stdout, text="Results writing", prespace=2) # If this is the final model selection round, check which models have been tested. if model == None: models_tested = [] for spin, spin_id in spin_loop(return_id=True, skip_desel=True): spin_model = spin.model # Add to list, if not in already. if spin_model not in models_tested: models_tested.append(spin_model) else: models_tested = None # Special for R2eff model. if model == MODEL_R2EFF: # The R2eff parameter. self.interpreter.value.write(param='r2eff', file='r2eff.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2eff', file='r2eff.agr', dir=path, force=True) # Exponential curves. if has_exponential_exp_type(): self.interpreter.relax_disp.plot_exp_curves(file='intensities.agr', dir=path, force=True) # Average peak intensities. self.interpreter.relax_disp.plot_exp_curves(file='intensities_norm.agr', dir=path, force=True, norm=True) # Average peak intensities (normalised). # The I0 parameter. self.interpreter.value.write(param='i0', file='i0.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='i0', file='i0.agr', dir=path, force=True) # Dispersion curves. self.interpreter.relax_disp.plot_disp_curves(dir=path, force=True) self.interpreter.relax_disp.write_disp_curves(dir=path, force=True) # The selected models for the final run. if model == None: self.interpreter.value.write(param='model', file='model.out', dir=path, force=True) # For CPMG models. if has_cpmg_exp_type(): # The R20 parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2', file_name_ini='r20') # The R20A and R20B parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2a', file_name_ini='r20a') self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2b', file_name_ini='r20b') # For R1ho models. if has_r1rho_exp_type(): # The R1 parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r1') # The R1rho prime parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2', file_name_ini='r1rho_prime') # Plot specific R1rho graphs. if model in [None] + MODEL_LIST_R1RHO: self.interpreter.relax_disp.plot_disp_curves(dir=path, x_axis=X_AXIS_THETA, force=True) self.interpreter.relax_disp.plot_disp_curves(dir=path, y_axis=Y_AXIS_R2_R1RHO, x_axis=X_AXIS_W_EFF, force=True) self.interpreter.relax_disp.plot_disp_curves(dir=path, y_axis=Y_AXIS_R2_EFF, x_axis=X_AXIS_THETA, interpolate=INTERPOLATE_OFFSET, force=True) # The calculation of theta and w_eff parameter in R1rho experiments. if model in MODEL_LIST_R1RHO_FULL: self.interpreter.value.write(param='theta', file='theta.out', dir=path, force=True) self.interpreter.value.write(param='w_eff', file='w_eff.out', dir=path, force=True) # The pA and pB parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='pA') self.write_results_test(path=path, model=model, models_tested=models_tested, param='pB') # The pC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='pC') # The phi_ex parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex') # The phi_ex_B nd phi_ex_C parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex_B') self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex_C') # The dw parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw') # The dw_AB, dw_BC and dw_AC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_AC') # The dwH parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH') # The dwH_AB, dwH_BC and dwH_AC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_AC') # The k_AB, kex and tex parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='k_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex') self.write_results_test(path=path, model=model, models_tested=models_tested, param='tex') # The kex_AB, kex_BC, kex_AC parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_AC') # The kB and kC parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='kB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kC') # Minimisation statistics. if not (model == MODEL_R2EFF and has_fixed_time_exp_type()): self.interpreter.value.write(param='chi2', file='chi2.out', dir=path, force=True) self.interpreter.grace.write(y_data_type='chi2', file='chi2.agr', dir=path, force=True) # Finally save the results. This is last to allow the continuation of an interrupted analysis while ensuring that all results files have been created. self.interpreter.results.write(file='results', dir=path, force=True)
value.set(param='cone_theta', val=0.8) # Fix the true pivot point. frame_order.pivot([ 37.254, 0.5, 16.7465], fix=True) # Change the model. frame_order.select_model('iso cone') # Loop over the 2 permutations. pipe_name = 'iso cone' tag = '' for perm in [None, 'A']: # The original permutation. if perm == None: # Title printout. section(file=sys.stdout, text="Isotropic cone original permutation") # Create a new data base data pipe for the iso cone. pipe.copy(pipe_from='frame order', pipe_to='iso cone') pipe.switch(pipe_name='iso cone') # Operations for the 'A' and 'B' permutations. else: # Title printout. section(file=sys.stdout, text="Isotropic cone permutation %s" % perm) # The pipe name and tag. pipe_name = 'iso cone perm %s' % perm tag = '_perm_%s' % perm # Create a new data pipe.
value.set(param='cone_theta_y', val=0.6) # Fix the true pivot point. frame_order.pivot([ 37.254, 0.5, 16.7465], fix=True) # Change the model. frame_order.select_model('pseudo-ellipse') # Loop over the 3 permutations. pipe_name = 'pseudo-ellipse' tag = '' for perm in [None, 'A', 'B']: # The original permutation. if perm == None: # Title printout. section(file=sys.stdout, text="Pseudo-ellipse original permutation") # Create a new data base data pipe for the pseudo-ellipse. pipe.copy(pipe_from='frame order', pipe_to='pseudo-ellipse') pipe.switch(pipe_name='pseudo-ellipse') # Operations for the 'A' and 'B' permutations. else: # Title printout. section(file=sys.stdout, text="Pseudo-ellipse permutation %s" % perm) # The pipe name and tag. pipe_name = 'pseudo-ellipse perm %s' % perm tag = '_perm_%s' % perm # Create a new data pipe.
def error_analysis(self): """Perform an error analysis of the peak intensities.""" # Printout. section(file=sys.stdout, text="Error analysis", prespace=2) # Check if intensity errors have already been calculated by the user. precalc = True for spin in spin_loop(skip_desel=True): # No structure. if not hasattr(spin, 'peak_intensity_err'): precalc = False break # Determine if a spectrum ID is missing from the list. for id in cdp.spectrum_ids: if id not in spin.peak_intensity_err: precalc = False break # Skip. if precalc: print( "Skipping the error analysis as it has already been performed." ) return # Check if there is replicates, and the user has not specified them. # Set flag for dublicates. has_dub = False if not hasattr(cdp, 'replicates'): # Collect all times, and matching spectrum ID. all_times = [] all_id = [] for spectrum_id in cdp.relax_times: all_times.append(cdp.relax_times[spectrum_id]) all_id.append(spectrum_id) # Get the dublicates. dublicates = [ (val, [i for i in range(len(all_times)) if all_times[i] == val]) for val in all_times ] # Loop over the list of the mapping of times and duplications. list_dub_mapping = [] for i, dub in enumerate(dublicates): # Get current spectum id. cur_spectrum_id = all_id[i] # Get the tuple of time and indexes of duplications. time, list_index_occur = dub # Collect mapping of index to id. id_list = [] if len(list_index_occur) > 1: # There exist dublications. has_dub = True for list_index in list_index_occur: id_list.append(all_id[list_index]) # Store to list list_dub_mapping.append((cur_spectrum_id, id_list)) # If there is dublication, then assign them. if has_dub: # Assign dublicates. for spectrum_id, dub_pair in list_dub_mapping: if len(dub_pair) > 0: self.interpreter.spectrum.replicated(spectrum_ids=dub_pair) # Run the error analysis. self.interpreter.spectrum.error_analysis()
value.set(param='cone_theta', val=0.8) # Fix the true pivot point. frame_order.pivot([37.254, 0.5, 16.7465], fix=True) # Change the model. frame_order.select_model('iso cone') # Loop over the 2 permutations. pipe_name = 'iso cone' tag = '' for perm in [None, 'A']: # The original permutation. if perm == None: # Title printout. section(file=sys.stdout, text="Isotropic cone original permutation") # Create a new data base data pipe for the iso cone. pipe.copy(pipe_from='frame order', pipe_to='iso cone') pipe.switch(pipe_name='iso cone') # Operations for the 'A' and 'B' permutations. else: # Title printout. section(file=sys.stdout, text="Isotropic cone permutation %s" % perm) # The pipe name and tag. pipe_name = 'iso cone perm %s' % perm tag = '_perm_%s' % perm # Create a new data pipe.
def run(self): """Execute the auto-analysis.""" # Peak intensity error analysis. if MODEL_R2EFF in self.models: self.error_analysis() # Loop over the models. self.model_pipes = [] for model in self.models: # Printout. subtitle(file=sys.stdout, text="The '%s' model" % model, prespace=3) # The results directory path. path = self.results_dir+sep+model # The name of the data pipe for the model. model_pipe = model if self.is_model_for_selection(model): self.model_pipes.append(model_pipe) # Check that results do not already exist - i.e. a previous run was interrupted. path1 = path + sep + 'results' path2 = path1 + '.bz2' path3 = path1 + '.gz' if access(path1, F_OK) or access(path2, F_OK) or access(path2, F_OK): # Printout. print("Detected the presence of results files for the '%s' model - loading these instead of performing optimisation for a second time." % model) # Create a data pipe and switch to it. self.interpreter.pipe.create(pipe_name=model_pipe, pipe_type='relax_disp', bundle=self.pipe_bundle) self.interpreter.pipe.switch(model_pipe) # Load the results. self.interpreter.results.read(file='results', dir=path) # Jump to the next model. continue # Create the data pipe by copying the base pipe, then switching to it. self.interpreter.pipe.copy(pipe_from=self.pipe_name, pipe_to=model_pipe, bundle_to=self.pipe_bundle) self.interpreter.pipe.switch(model_pipe) # Select the model. self.interpreter.relax_disp.select_model(model) # Copy the R2eff values from the R2eff model data pipe. if model != MODEL_R2EFF and MODEL_R2EFF in self.models: self.interpreter.value.copy(pipe_from=MODEL_R2EFF, pipe_to=model, param='r2eff') # Calculate the R2eff values for the fixed relaxation time period data types. if model == MODEL_R2EFF and not has_exponential_exp_type(): self.interpreter.calc() # Optimise the model. else: self.optimise(model=model) # Write out the results. self.write_results(path=path, model=model) # The final model selection data pipe. if len(self.models) >= 2: # Printout. section(file=sys.stdout, text="Final results", prespace=2) # Perform model selection. self.interpreter.model_selection(method=self.modsel, modsel_pipe='final', bundle=self.pipe_bundle, pipes=self.model_pipes) # Final Monte Carlo simulations only. if not self.mc_sim_all_models: self.interpreter.monte_carlo.setup(number=self.mc_sim_num) self.interpreter.monte_carlo.create_data() self.interpreter.monte_carlo.initial_values() self.interpreter.minimise('simplex', func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=True) if self.eliminate: self.interpreter.eliminate() self.interpreter.monte_carlo.error_analysis() # Writing out the final results. self.write_results(path=self.results_dir+sep+'final') # No model selection. else: warn(RelaxWarning("Model selection in the dispersion auto-analysis has been skipped as only %s models have been optimised." % len(self.model_pipes))) # Finally save the program state. self.interpreter.state.save(state='final_state', dir=self.results_dir, force=True)
def optimise(self, model=None, model_path=None): """Optimise the model, taking model nesting into account. @keyword model: The model to be optimised. @type model: str @keyword model_path: The folder name for the model, where possible spaces has been replaced with underscore. @type model_path: str """ # Printout. section(file=sys.stdout, text="Optimisation", prespace=2) # Deselect insignificant spins. if model not in [MODEL_R2EFF, MODEL_NOREX]: self.interpreter.relax_disp.insignificance( level=self.insignificance) # Speed-up grid-search by using minium R2eff value. if self.set_grid_r20 and model != MODEL_R2EFF: self.interpreter.relax_disp.r20_from_min_r2eff(force=True) # Use pre-run results as the optimisation starting point. # Test if file exists. if self.pre_run_dir: path = self.pre_run_dir + sep + model_path # File path. file_path = get_file_path('results', path) # Test if the file exists and determine the compression type. try: compress_type, file_path = determine_compression(file_path) res_file_exists = True except RelaxFileError: res_file_exists = False if self.pre_run_dir and res_file_exists: self.pre_run_parameters(model=model, model_path=model_path) # Otherwise use the normal nesting check and grid search if not nested. else: # Nested model simplification. nested = self.nesting(model=model) # Otherwise use a grid search of default values to start optimisation with. if not nested: # Grid search. if self.grid_inc: self.interpreter.minimise.grid_search(inc=self.grid_inc) # Default values. else: # The standard parameters. for param in MODEL_PARAMS[model]: self.interpreter.value.set(param=param, index=None) # The optional R1 parameter. if is_r1_optimised(model=model): self.interpreter.value.set(param='r1', index=None) # 'R2eff' model minimisation flags. do_minimise = False if model == MODEL_R2EFF: # The constraints flag. constraints = False # The minimisation algorithm to use. # Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used. min_algor = 'Newton' # Check if all spins contains 'r2eff and it associated error. has_r2eff = False # Loop over all spins. for cur_spin, spin_id in spin_loop(return_id=True, skip_desel=True): # Check 'r2eff' if hasattr(cur_spin, 'r2eff') and hasattr( cur_spin, 'r2eff_err'): has_r2eff = True else: has_r2eff = False break # Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised. if has_r2eff and not self.optimise_r2eff: pass # Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised. elif has_r2eff and self.optimise_r2eff: do_minimise = True # Optimise, if no R2eff and error is present. elif not has_r2eff: do_minimise = True # Dispersion model minimisation flags. else: do_minimise = True constraints = True # The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used. min_algor = 'simplex' # Do the minimisation. if do_minimise: self.interpreter.minimise.execute(min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints) # Model elimination. if self.eliminate: self.interpreter.eliminate() # Monte Carlo simulations. do_monte_carlo = False if model == MODEL_R2EFF: # The constraints flag. constraints = False # Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used. min_algor = 'Newton' # Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised. if has_r2eff and not self.optimise_r2eff: pass # Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised. elif has_r2eff and self.optimise_r2eff: do_monte_carlo = True # Optimise, if no R2eff and error is present. elif not has_r2eff: do_monte_carlo = True elif self.mc_sim_all_models or len(self.models) < 2: do_monte_carlo = True # The constraints flag. constraints = True # The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used. min_algor = 'simplex' # Error estimation by Monte Carlo simulations. if do_monte_carlo: # Set the number of Monte-Carlo simulations. monte_carlo_sim = self.mc_sim_num # If the number for exponential curve fitting has been set. if model == MODEL_R2EFF and self.exp_mc_sim_num != None: monte_carlo_sim = self.exp_mc_sim_num # When set to minus 1, estimation of the errors will be extracted from the covariance matrix. # This is HIGHLY likely to be wrong, but can be used in an initial test fase. if model == MODEL_R2EFF and self.exp_mc_sim_num == -1: # Print subsection(file=sys.stdout, text="Estimating errors from Covariance matrix", prespace=1) # Raise warning. text = 'Estimating errors from the Covariance matrix is highly likely to be "quite" wrong. Use only with extreme care, and for initial rapid testing of your data.' warn(RelaxWarning(text)) # Estimate errors self.interpreter.relax_disp.r2eff_err_estimate() else: self.interpreter.monte_carlo.setup(number=monte_carlo_sim) self.interpreter.monte_carlo.create_data() self.interpreter.monte_carlo.initial_values() self.interpreter.minimise.execute( min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints) if self.eliminate: self.interpreter.eliminate() self.interpreter.monte_carlo.error_analysis()
def write_results(self, path=None, model=None): """Create a set of results, text and Grace files for the current data pipe. @keyword path: The directory to place the files into. @type path: str """ # Printout. section(file=sys.stdout, text="Results writing", prespace=2) # If this is the final model selection round, check which models have been tested. if model == None: models_tested = [] for spin, spin_id in spin_loop(return_id=True, skip_desel=True): spin_model = spin.model # Add to list, if not in already. if spin_model not in models_tested: models_tested.append(spin_model) else: models_tested = None # Special for R2eff model. if model == MODEL_R2EFF: # The R2eff parameter. self.interpreter.value.write(param='r2eff', file='r2eff.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2eff', file='r2eff.agr', dir=path, force=True) # Exponential curves. if has_exponential_exp_type(): self.interpreter.relax_disp.plot_exp_curves( file='intensities.agr', dir=path, force=True) # Average peak intensities. self.interpreter.relax_disp.plot_exp_curves( file='intensities_norm.agr', dir=path, force=True, norm=True) # Average peak intensities (normalised). # The I0 parameter. self.interpreter.value.write(param='i0', file='i0.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='i0', file='i0.agr', dir=path, force=True) # Dispersion curves. self.interpreter.relax_disp.plot_disp_curves(dir=path, force=True) self.interpreter.relax_disp.write_disp_curves(dir=path, force=True) # The selected models for the final run. if model == None: self.interpreter.value.write(param='model', file='model.out', dir=path, force=True) # For CPMG models. if has_cpmg_exp_type(): # The R20 parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2', file_name_ini='r20') # The R20A and R20B parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2a', file_name_ini='r20a') self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2b', file_name_ini='r20b') # For R1ho models. if has_r1rho_exp_type(): # The R1 parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r1') # The R1rho prime parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='r2', file_name_ini='r1rho_prime') # Plot specific R1rho graphs. if model in [None] + MODEL_LIST_R1RHO: self.interpreter.relax_disp.plot_disp_curves( dir=path, x_axis=X_AXIS_THETA, force=True) self.interpreter.relax_disp.plot_disp_curves( dir=path, y_axis=Y_AXIS_R2_R1RHO, x_axis=X_AXIS_W_EFF, force=True) self.interpreter.relax_disp.plot_disp_curves( dir=path, y_axis=Y_AXIS_R2_EFF, x_axis=X_AXIS_THETA, interpolate=INTERPOLATE_OFFSET, force=True) # The calculation of theta and w_eff parameter in R1rho experiments. if model in MODEL_LIST_R1RHO_FULL: self.interpreter.value.write(param='theta', file='theta.out', dir=path, force=True) self.interpreter.value.write(param='w_eff', file='w_eff.out', dir=path, force=True) # The pA and pB parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='pA') self.write_results_test(path=path, model=model, models_tested=models_tested, param='pB') # The pC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='pC') # The phi_ex parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex') # The phi_ex_B nd phi_ex_C parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex_B') self.write_results_test(path=path, model=model, models_tested=models_tested, param='phi_ex_C') # The dw parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw') # The dw_AB, dw_BC and dw_AC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dw_AC') # The dwH parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH') # The dwH_AB, dwH_BC and dwH_AC parameter. self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='dwH_AC') # The k_AB, kex and tex parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='k_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex') self.write_results_test(path=path, model=model, models_tested=models_tested, param='tex') # The kex_AB, kex_BC, kex_AC parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_AB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_BC') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kex_AC') # The kB and kC parameters. self.write_results_test(path=path, model=model, models_tested=models_tested, param='kB') self.write_results_test(path=path, model=model, models_tested=models_tested, param='kC') # Minimisation statistics. if not (model == MODEL_R2EFF and has_fixed_time_exp_type()): self.interpreter.value.write(param='chi2', file='chi2.out', dir=path, force=True) self.interpreter.grace.write(y_data_type='chi2', file='chi2.agr', dir=path, force=True) # Finally save the results. This is last to allow the continuation of an interrupted analysis while ensuring that all results files have been created. self.interpreter.results.write(file='results', dir=path, force=True)
def write_results(self, path=None, model=None): """Create a set of results, text and Grace files for the current data pipe. @keyword path: The directory to place the files into. @type path: str """ # Printout. section(file=sys.stdout, text="Results writing", prespace=2) # Exponential curves. if model == 'R2eff' and has_exponential_exp_type(): self.interpreter.relax_disp.plot_exp_curves(file='intensities.agr', dir=path, force=True) # Average peak intensities. self.interpreter.relax_disp.plot_exp_curves(file='intensities_norm.agr', dir=path, force=True, norm=True) # Average peak intensities (normalised). # Dispersion curves. self.interpreter.relax_disp.plot_disp_curves(dir=path, force=True) self.interpreter.relax_disp.write_disp_curves(dir=path, force=True) # The selected models for the final run. if model == None: self.interpreter.value.write(param='model', file='model.out', dir=path, force=True) # The R2eff parameter. if model == 'R2eff': self.interpreter.value.write(param='r2eff', file='r2eff.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2eff', file='r2eff.agr', dir=path, force=True) # The I0 parameter. if model == 'R2eff' and has_exponential_exp_type(): self.interpreter.value.write(param='i0', file='i0.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='i0', file='i0.agr', dir=path, force=True) ## The R20 parameter. #if has_cpmg_exp_type() and model in [None, MODEL_LM63, MODEL_CR72, MODEL_IT99, MODEL_M61, MODEL_DPL94, MODEL_M61B, MODEL_MMQ_CR72, MODEL_NS_CPMG_2SITE_3D, MODEL_NS_CPMG_2SITE_STAR, MODEL_NS_CPMG_2SITE_EXPANDED, MODEL_NS_MMQ_2SITE, MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR]: # self.interpreter.value.write(param='r2', file='r20.out', dir=path, force=True) # self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2', file='r20.agr', dir=path, force=True) ## The R20A and R20B parameters. #if has_cpmg_exp_type() and model in [None, MODEL_CR72_FULL, MODEL_NS_CPMG_2SITE_3D_FULL, MODEL_NS_CPMG_2SITE_STAR_FULL]: # self.interpreter.value.write(param='r2a', file='r20a.out', dir=path, force=True) # self.interpreter.value.write(param='r2b', file='r20b.out', dir=path, force=True) # self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2a', file='r20a.agr', dir=path, force=True) # self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2b', file='r20b.agr', dir=path, force=True) ## The R1rho parameter. #if has_r1rho_exp_type() and model in [None] + MODEL_LIST_R1RHO: # self.interpreter.value.write(param='r2', file='r1rho0.out', dir=path, force=True) # self.interpreter.grace.write(x_data_type='res_num', y_data_type='r2', file='r1rho0.agr', dir=path, force=True) # The pA, pB, and pC parameters. if model in [None, MODEL_CR72, MODEL_CR72_FULL, MODEL_IT99, MODEL_M61B, MODEL_MMQ_CR72, MODEL_NS_CPMG_2SITE_3D, MODEL_NS_CPMG_2SITE_3D_FULL, MODEL_NS_CPMG_2SITE_STAR, MODEL_NS_CPMG_2SITE_STAR_FULL, MODEL_NS_CPMG_2SITE_EXPANDED, MODEL_NS_MMQ_2SITE, MODEL_NS_R1RHO_2SITE, MODEL_NS_R1RHO_3SITE, MODEL_NS_R1RHO_3SITE_LINEAR, MODEL_TP02, MODEL_TAP03, MODEL_MP05, MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR]: self.interpreter.value.write(param='pA', file='pA.out', dir=path, force=True) self.interpreter.value.write(param='pB', file='pB.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='pA', file='pA.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='pB', file='pB.agr', dir=path, force=True) if model in [MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR, MODEL_NS_R1RHO_3SITE, MODEL_NS_R1RHO_3SITE_LINEAR]: self.interpreter.value.write(param='pC', file='pC.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='pC', file='pC.agr', dir=path, force=True) # The Phi_ex parameter. if model in [None, MODEL_LM63, MODEL_M61, MODEL_DPL94]: self.interpreter.value.write(param='phi_ex', file='phi_ex.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='phi_ex', file='phi_ex.agr', dir=path, force=True) # The Phi_ex_B nd Phi_ex_C parameters. if model in [None, MODEL_LM63_3SITE]: self.interpreter.value.write(param='phi_ex_B', file='phi_ex_B.out', dir=path, force=True) self.interpreter.value.write(param='phi_ex_C', file='phi_ex_C.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='phi_ex_B', file='phi_ex_B.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='phi_ex_C', file='phi_ex_C.agr', dir=path, force=True) # The dw parameter. if model in [None, MODEL_CR72, MODEL_CR72_FULL, MODEL_IT99, MODEL_M61B, MODEL_MMQ_CR72, MODEL_NS_CPMG_2SITE_3D, MODEL_NS_CPMG_2SITE_3D_FULL, MODEL_NS_CPMG_2SITE_STAR, MODEL_NS_CPMG_2SITE_STAR_FULL, MODEL_NS_CPMG_2SITE_EXPANDED, MODEL_NS_MMQ_2SITE, MODEL_NS_R1RHO_2SITE, MODEL_TP02, MODEL_TAP03, MODEL_MP05, MODEL_TSMFK01]: self.interpreter.value.write(param='dw', file='dw.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dw', file='dw.agr', dir=path, force=True) if model in [MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR, MODEL_NS_R1RHO_3SITE, MODEL_NS_R1RHO_3SITE_LINEAR]: self.interpreter.value.write(param='dw_AB', file='dw_AB.out', dir=path, force=True) self.interpreter.value.write(param='dw_BC', file='dw_BC.out', dir=path, force=True) self.interpreter.value.write(param='dw_AC', file='dw_AC.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dw_AB', file='dw_AB.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dw_BC', file='dw_BC.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dw_AC', file='dw_AC.agr', dir=path, force=True) # The dwH parameter. if model in [None, MODEL_MMQ_CR72, MODEL_NS_MMQ_2SITE]: self.interpreter.value.write(param='dwH', file='dwH.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dwH', file='dwH.agr', dir=path, force=True) if model in [MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR]: self.interpreter.value.write(param='dwH_AB', file='dwH_AB.out', dir=path, force=True) self.interpreter.value.write(param='dwH_BC', file='dwH_BC.out', dir=path, force=True) self.interpreter.value.write(param='dwH_AC', file='dwH_AC.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dwH_AB', file='dwH_AB.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dwH_BC', file='dwH_BC.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='dwH_AC', file='dwH_AC.agr', dir=path, force=True) # The k_AB, kex and tex parameters. if model in [None, MODEL_LM63, MODEL_CR72, MODEL_CR72_FULL, MODEL_IT99, MODEL_M61, MODEL_DPL94, MODEL_M61B, MODEL_MMQ_CR72, MODEL_NS_CPMG_2SITE_3D, MODEL_NS_CPMG_2SITE_3D_FULL, MODEL_NS_CPMG_2SITE_STAR, MODEL_NS_CPMG_2SITE_STAR_FULL, MODEL_NS_CPMG_2SITE_EXPANDED, MODEL_NS_MMQ_2SITE, MODEL_NS_R1RHO_2SITE, MODEL_TP02, MODEL_TAP03, MODEL_MP05]: self.interpreter.value.write(param='k_AB', file='k_AB.out', dir=path, force=True) self.interpreter.value.write(param='kex', file='kex.out', dir=path, force=True) self.interpreter.value.write(param='tex', file='tex.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='k_AB', file='k_AB.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kex', file='kex.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='tex', file='tex.agr', dir=path, force=True) if model in [MODEL_NS_MMQ_3SITE, MODEL_NS_MMQ_3SITE_LINEAR, MODEL_NS_R1RHO_3SITE, MODEL_NS_R1RHO_3SITE_LINEAR]: self.interpreter.value.write(param='kex_AB', file='kex_AB.out', dir=path, force=True) self.interpreter.value.write(param='kex_BC', file='kex_BC.out', dir=path, force=True) self.interpreter.value.write(param='kex_AC', file='kex_AC.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kex_AB', file='kex_AB.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kex_BC', file='kex_BC.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kex_AC', file='kex_AC.agr', dir=path, force=True) # The k_AB parameter. if model in [None, MODEL_TSMFK01]: self.interpreter.value.write(param='k_AB', file='k_AB.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='k_AB', file='k_AB.agr', dir=path, force=True) # The kB and kC parameters. if model in [None, MODEL_LM63_3SITE]: self.interpreter.value.write(param='kB', file='kB.out', dir=path, force=True) self.interpreter.value.write(param='kC', file='kC.out', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kB', file='kB.agr', dir=path, force=True) self.interpreter.grace.write(x_data_type='res_num', y_data_type='kC', file='kC.agr', dir=path, force=True) # Minimisation statistics. if not (model == 'R2eff' and has_fixed_time_exp_type()): self.interpreter.grace.write(y_data_type='chi2', file='chi2.agr', dir=path, force=True) # Finally save the results. This is last to allow the continuation of an interrupted analysis while ensuring that all results files have been created. self.interpreter.results.write(file='results', dir=path, force=True)
def optimise(self, model=None, model_path=None): """Optimise the model, taking model nesting into account. @keyword model: The model to be optimised. @type model: str @keyword model_path: The folder name for the model, where possible spaces has been replaced with underscore. @type model_path: str """ # Printout. section(file=sys.stdout, text="Optimisation", prespace=2) # Deselect insignificant spins. if model not in [MODEL_R2EFF, MODEL_NOREX]: self.interpreter.relax_disp.insignificance(level=self.insignificance) # Speed-up grid-search by using minium R2eff value. if self.set_grid_r20 and model != MODEL_R2EFF: self.interpreter.relax_disp.r20_from_min_r2eff(force=True) # Use pre-run results as the optimisation starting point. # Test if file exists. if self.pre_run_dir: path = self.pre_run_dir + sep + model_path # File path. file_path = get_file_path('results', path) # Test if the file exists and determine the compression type. try: compress_type, file_path = determine_compression(file_path) res_file_exists = True except RelaxFileError: res_file_exists = False if self.pre_run_dir and res_file_exists: self.pre_run_parameters(model=model, model_path=model_path) # Otherwise use the normal nesting check and grid search if not nested. else: # Nested model simplification. nested = self.nesting(model=model) # Otherwise use a grid search of default values to start optimisation with. if not nested: # Grid search. if self.grid_inc: self.interpreter.minimise.grid_search(inc=self.grid_inc) # Default values. else: # The standard parameters. for param in MODEL_PARAMS[model]: self.interpreter.value.set(param=param, index=None) # The optional R1 parameter. if is_r1_optimised(model=model): self.interpreter.value.set(param='r1', index=None) # 'R2eff' model minimisation flags. do_minimise = False if model == MODEL_R2EFF: # The constraints flag. constraints = False # The minimisation algorithm to use. # Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used. min_algor = 'Newton' # Check if all spins contains 'r2eff and it associated error. has_r2eff = False # Loop over all spins. for cur_spin, spin_id in spin_loop(return_id=True, skip_desel=True): # Check 'r2eff' if hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'r2eff_err'): has_r2eff = True else: has_r2eff = False break # Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised. if has_r2eff and not self.optimise_r2eff: pass # Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised. elif has_r2eff and self.optimise_r2eff: do_minimise = True # Optimise, if no R2eff and error is present. elif not has_r2eff: do_minimise = True # Dispersion model minimisation flags. else: do_minimise = True constraints = True # The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used. min_algor = 'simplex' # Do the minimisation. if do_minimise: self.interpreter.minimise.execute(min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints) # Model elimination. if self.eliminate: self.interpreter.eliminate() # Monte Carlo simulations. do_monte_carlo = False if model == MODEL_R2EFF: # The constraints flag. constraints = False # Both the Jacobian and Hessian matrix has been specified for exponential curve-fitting, allowing for the much faster algorithms to be used. min_algor = 'Newton' # Skip optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is not raised. if has_r2eff and not self.optimise_r2eff: pass # Do optimisation, if 'r2eff' + 'r2eff_err' is present and flag for forcing optimisation is raised. elif has_r2eff and self.optimise_r2eff: do_monte_carlo = True # Optimise, if no R2eff and error is present. elif not has_r2eff: do_monte_carlo = True elif self.mc_sim_all_models or len(self.models) < 2: do_monte_carlo = True # The constraints flag. constraints = True # The minimisation algorithm to use. If the Jacobian and Hessian matrix have not been specified for fitting, 'simplex' should be used. min_algor = 'simplex' # Error estimation by Monte Carlo simulations. if do_monte_carlo: # Set the number of Monte-Carlo simulations. monte_carlo_sim = self.mc_sim_num # If the number for exponential curve fitting has been set. if model == MODEL_R2EFF and self.exp_mc_sim_num != None: monte_carlo_sim = self.exp_mc_sim_num # When set to minus 1, estimation of the errors will be extracted from the covariance matrix. # This is HIGHLY likely to be wrong, but can be used in an initial test fase. if model == MODEL_R2EFF and self.exp_mc_sim_num == -1: # Print subsection(file=sys.stdout, text="Estimating errors from Covariance matrix", prespace=1) # Raise warning. text = 'Estimating errors from the Covariance matrix is highly likely to be "quite" wrong. Use only with extreme care, and for initial rapid testing of your data.' warn(RelaxWarning(text)) # Estimate errors self.interpreter.relax_disp.r2eff_err_estimate() else: self.interpreter.monte_carlo.setup(number=monte_carlo_sim) self.interpreter.monte_carlo.create_data() self.interpreter.monte_carlo.initial_values() self.interpreter.minimise.execute(min_algor=min_algor, func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=constraints) if self.eliminate: self.interpreter.eliminate() self.interpreter.monte_carlo.error_analysis()
def run(self): """Execute the auto-analysis.""" # Peak intensity error analysis. if MODEL_R2EFF in self.models: self.error_analysis() # R1 parameter fitting. if self.r1_fit: subtitle(file=sys.stdout, text="R1 parameter optimisation activation", prespace=3) self.interpreter.relax_disp.r1_fit(fit=self.r1_fit) else: # No print out. self.interpreter.relax_disp.r1_fit(fit=self.r1_fit) # Loop over the models. self.model_pipes = [] for model in self.models: # Printout. subtitle(file=sys.stdout, text="The '%s' model" % model, prespace=3) # The results directory path. model_path = model.replace(" ", "_") path = self.results_dir + sep + model_path # The name of the data pipe for the model. model_pipe = self.name_pipe(model) if self.is_model_for_selection(model): self.model_pipes.append(model_pipe) # Check that results do not already exist - i.e. a previous run was interrupted. path1 = path + sep + 'results' path2 = path1 + '.bz2' path3 = path1 + '.gz' if access(path1, F_OK) or access(path2, F_OK) or access( path2, F_OK): # Printout. print( "Detected the presence of results files for the '%s' model - loading these instead of performing optimisation for a second time." % model) # Create a data pipe and switch to it. self.interpreter.pipe.create(pipe_name=model_pipe, pipe_type='relax_disp', bundle=self.pipe_bundle) self.interpreter.pipe.switch(model_pipe) # Load the results. self.interpreter.results.read(file='results', dir=path) # Jump to the next model. continue # Create the data pipe by copying the base pipe, then switching to it. self.interpreter.pipe.copy(pipe_from=self.pipe_name, pipe_to=model_pipe, bundle_to=self.pipe_bundle) self.interpreter.pipe.switch(model_pipe) # Select the model. self.interpreter.relax_disp.select_model(model) # Copy the R2eff values from the R2eff model data pipe. if model != MODEL_R2EFF and MODEL_R2EFF in self.models: self.interpreter.value.copy( pipe_from=self.name_pipe(MODEL_R2EFF), pipe_to=model_pipe, param='r2eff') # Calculate the R2eff values for the fixed relaxation time period data types. if model == MODEL_R2EFF and not has_exponential_exp_type(): self.interpreter.minimise.calculate() # Optimise the model. else: self.optimise(model=model, model_path=model_path) # Write out the results. self.write_results(path=path, model=model) # The final model selection data pipe. if len(self.models) >= 2: # Printout. section(file=sys.stdout, text="Final results", prespace=2) # Perform model selection. self.interpreter.model_selection( method=self.modsel, modsel_pipe=self.name_pipe('final'), bundle=self.pipe_bundle, pipes=self.model_pipes) # Final Monte Carlo simulations only. if not self.mc_sim_all_models: self.interpreter.monte_carlo.setup(number=self.mc_sim_num) self.interpreter.monte_carlo.create_data() self.interpreter.monte_carlo.initial_values() self.interpreter.minimise.execute( 'simplex', func_tol=self.opt_func_tol, max_iter=self.opt_max_iterations, constraints=True) if self.eliminate: self.interpreter.eliminate() self.interpreter.monte_carlo.error_analysis() # Writing out the final results. self.write_results(path=self.results_dir + sep + 'final') # No model selection. else: warn( RelaxWarning( "Model selection in the dispersion auto-analysis has been skipped as only %s models have been optimised." % len(self.model_pipes))) # Finally save the program state. self.interpreter.state.save(state='final_state', dir=self.results_dir, force=True)
def error_analysis(self): """Perform an error analysis of the peak intensities.""" # Printout. section(file=sys.stdout, text="Error analysis", prespace=2) # Check if intensity errors have already been calculated by the user. precalc = True for spin in spin_loop(skip_desel=True): # No structure. if not hasattr(spin, 'peak_intensity_err'): precalc = False break # Determine if a spectrum ID is missing from the list. for id in cdp.spectrum_ids: if id not in spin.peak_intensity_err: precalc = False break # Skip. if precalc: print("Skipping the error analysis as it has already been performed.") return # Check if there is replicates, and the user has not specified them. # Set flag for dublicates. has_dub = False if not hasattr(cdp, 'replicates'): # Collect all times, and matching spectrum ID. all_times = [] all_id = [] for spectrum_id in cdp.relax_times: all_times.append(cdp.relax_times[spectrum_id]) all_id.append(spectrum_id) # Get the dublicates. dublicates = [(val, [i for i in range(len(all_times)) if all_times[i] == val]) for val in all_times] # Loop over the list of the mapping of times and duplications. list_dub_mapping = [] for i, dub in enumerate(dublicates): # Get current spectum id. cur_spectrum_id = all_id[i] # Get the tuple of time and indexes of duplications. time, list_index_occur = dub # Collect mapping of index to id. id_list = [] if len(list_index_occur) > 1: # There exist dublications. has_dub = True for list_index in list_index_occur: id_list.append(all_id[list_index]) # Store to list list_dub_mapping.append((cur_spectrum_id, id_list)) # If there is dublication, then assign them. if has_dub: # Assign dublicates. for spectrum_id, dub_pair in list_dub_mapping: if len(dub_pair) > 0: self.interpreter.spectrum.replicated(spectrum_ids=dub_pair) # Run the error analysis. self.interpreter.spectrum.error_analysis()
def summary_skipped(self): """Print out information about skipped tests.""" # Counts. system_count = {} unit_count = {} gui_count = {} verification_count = {} for i in range(len(status.skipped_tests)): # Alias. test = status.skipped_tests[i] # Skip all skipped tests whereby the module is set to None to indicate that the test skipping should not be reported. if test[1] == None: continue # Initialise in needed. if not test[1] in system_count: system_count[test[1]] = 0 unit_count[test[1]] = 0 gui_count[test[1]] = 0 verification_count[test[1]] = 0 # A system test. if test[2] == 'system': system_count[test[1]] += 1 # A unit test. if test[2] == 'unit': unit_count[test[1]] += 1 # A GUI test. if test[2] == 'gui': gui_count[test[1]] += 1 # A verification test. if test[2] == 'verification': verification_count[test[1]] += 1 # The missing modules. missing_modules = sorted(system_count.keys()) section(file=sys.stdout, text="Optional packages/modules") # Nothing missing. if not missing_modules: # Except for the wx module! if not dep_check.wx_module and hasattr(self, 'gui_result'): print( "All GUI tests skipped due to the missing wxPython module, no other tests skipped due to missing modules.\n" ) # Normal printout. else: print("No tests skipped due to missing modules.\n") # The skip the table. return # Header. print( "Tests skipped due to missing optional packages/modules/software:\n" ) header = "%-33s" % "Module/package/software" if len(system_count): header = "%s %20s" % (header, "System test count") if len(unit_count): header = "%s %20s" % (header, "Unit test count") if len(gui_count): header = "%s %20s" % (header, "GUI test count") if len(verification_count): header = "%s %20s" % (header, "Verification test count") print('-' * len(header)) print(header) print('-' * len(header)) # The table. for module in missing_modules: text = "%-33s" % module if len(system_count): text = "%s %20s" % (text, system_count[module]) if len(unit_count): text = "%s %20s" % (text, unit_count[module]) if len(gui_count): text = "%s %20s" % (text, gui_count[module]) if len(verification_count): text = "%s %20s" % (text, verification_count[module]) print(text) # End the table. print('-' * len(header)) print("\n")
value.set(param='cone_theta_y', val=0.2) # Fix the true pivot point. frame_order.pivot([ 37.254, 0.5, 16.7465], fix=True) # Change the model. frame_order.select_model('pseudo-ellipse') # Loop over the 3 permutations. pipe_name = 'pseudo-ellipse' tag = '' for perm in [None, 'A', 'B']: # The original permutation. if perm == None: # Title printout. section(file=sys.stdout, text="Pseudo-ellipse original permutation") # Create a new data base data pipe for the pseudo-ellipse. pipe.copy(pipe_from='frame order', pipe_to='pseudo-ellipse') pipe.switch(pipe_name='pseudo-ellipse') # Operations for the 'A' and 'B' permutations. else: # Title printout. section(file=sys.stdout, text="Pseudo-ellipse permutation %s" % perm) # The pipe name and tag. pipe_name = 'pseudo-ellipse perm %s' % perm tag = '_perm_%s' % perm # Create a new data pipe.