def set(val=None, param=None, index=None, pipe=None, spin_id=None, verbosity=1, error=False, force=True, reset=True): """Set global or spin specific data values. @keyword val: The parameter values. @type val: None or list @keyword param: The parameter names. @type param: None, str, or list of str @keyword index: The index for parameters which are of the list-type. This is ignored for all other types. @type index: None or int @keyword pipe: The data pipe the values should be placed in. @type pipe: None or str @keyword spin_id: The spin identification string. @type spin_id: str @keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int @keyword error: A flag which if True will allow the parameter errors to be set instead of the values. @type error: bool @keyword force: A flag forcing the overwriting of current values. @type force: bool @keyword reset: A flag which if True will cause all minimisation statistics to be reset. @type reset: bool """ # Switch to the data pipe, storing the original. if pipe: orig_pipe = pipes.cdp_name() pipes.switch(pipe) # Test if the current data pipe exists. check_pipe() # The specific analysis API object. api = return_api() # Convert numpy arrays to lists, if necessary. if isinstance(val, ndarray): val = val.tolist() # Invalid combinations. if (isinstance(val, float) or isinstance(val, int)) and param == None: raise RelaxError("The combination of a single value '%s' without specifying the parameter name is invalid." % val) if isinstance(val, list) and isinstance(param, str): raise RelaxError("Invalid combination: When multiple values '%s' are specified, either no parameters or a list of parameters must by supplied rather than the single parameter '%s'." % (val, param)) # Value array and parameter array of equal length. if isinstance(val, list) and isinstance(param, list) and len(val) != len(param): raise RelaxError("Both the value array and parameter array must be of equal length.") # Get the parameter list if needed. if param == None: param = api.get_param_names() # Convert the param to a list if needed. if not isinstance(param, list): param = [param] # Convert the value to a list if needed. if val != None and not isinstance(val, list): val = [val] * len(param) # Default values. if val == None: # Loop over the parameters, getting the default values. val = [] for i in range(len(param)): val.append(api.default_value(param[i])) # Check that there is a default. if val[-1] == None: raise RelaxParamSetError(param[i]) # Set the parameter values. api.set_param_values(param=param, value=val, index=index, spin_id=spin_id, error=error, force=force) # Reset all minimisation statistics. if reset: minimise.reset_min_stats(verbosity=verbosity) # Switch back. if pipe: pipes.switch(orig_pipe)
def copy(pipe_from=None, pipe_to=None, param=None, force=False): """Copy spin specific data values from pipe_from to pipe_to. @param pipe_from: The data pipe to copy the value from. This defaults to the current data pipe. @type pipe_from: str @param pipe_to: The data pipe to copy the value to. This defaults to the current data pipe. @type pipe_to: str @param param: The name of the parameter to copy the values of. @type param: str @keyword force: A flag forcing the overwriting of current values. @type force: bool """ # The current data pipe. if pipe_from == None: pipe_from = pipes.cdp_name() if pipe_to == None: pipe_to = pipes.cdp_name() pipe_orig = pipes.cdp_name() # The second pipe does not exist. check_pipe(pipe_to) # Test if the sequence data for pipe_from is loaded. if not exists_mol_res_spin_data(pipe_from): raise RelaxNoSequenceError(pipe_from) # Test if the sequence data for pipe_to is loaded. if not exists_mol_res_spin_data(pipe_to): raise RelaxNoSequenceError(pipe_to) # The specific analysis API object. api = return_api(pipe_name=pipe_from) # Test if the data exists for pipe_to. if force == False: for spin in spin_loop(pipe=pipe_to): # Get the value and error for pipe_to. value, error = api.return_value(spin, param) # Data exists. if value != None or error != None: raise RelaxValueError(param, pipe_to) # Switch to the data pipe to copy values to. pipes.switch(pipe_to) # Copy the values. for spin, spin_id in spin_loop(pipe=pipe_from, return_id=True): # Get the value and error from pipe_from. value, error = api.return_value(spin, param) # Set the values of pipe_to. if value != None: set(spin_id=spin_id, val=value, param=param, pipe=pipe_to, force=force) if error != None: set(spin_id=spin_id, val=error, param=param, pipe=pipe_to, error=True, force=force) # Reset all minimisation statistics. minimise.reset_min_stats(pipe_to) # Switch back to the original current data pipe. pipes.switch(pipe_orig)
def read(param=None, scaling=1.0, file=None, dir=None, file_data=None, spin_id_col=None, mol_name_col=None, res_num_col=None, res_name_col=None, spin_num_col=None, spin_name_col=None, data_col=None, error_col=None, sep=None, spin_id=None): """Read spin specific data values from a file. @keyword param: The name of the parameter to read. @type param: str @keyword scaling: A scaling factor by which all read values are multiplied by. @type scaling: float @keyword file: The name of the file to open. @type file: str @keyword dir: The directory containing the file (defaults to the current directory if None). @type dir: str or None @keyword file_data: An alternative to opening a file, if the data already exists in the correct format. The format is a list of lists where the first index corresponds to the row and the second the column. @type file_data: list of lists @keyword spin_id_col: The column containing the spin ID strings. If supplied, the mol_name_col, res_name_col, res_num_col, spin_name_col, and spin_num_col arguments must be none. @type spin_id_col: int or None @keyword mol_name_col: The column containing the molecule name information. If supplied, spin_id_col must be None. @type mol_name_col: int or None @keyword res_name_col: The column containing the residue name information. If supplied, spin_id_col must be None. @type res_name_col: int or None @keyword res_num_col: The column containing the residue number information. If supplied, spin_id_col must be None. @type res_num_col: int or None @keyword spin_name_col: The column containing the spin name information. If supplied, spin_id_col must be None. @type spin_name_col: int or None @keyword spin_num_col: The column containing the spin number information. If supplied, spin_id_col must be None. @type spin_num_col: int or None @keyword data_col: The column containing the RDC data in Hz. @type data_col: int or None @keyword error_col: The column containing the RDC errors. @type error_col: int or None @keyword sep: The column separator which, if None, defaults to whitespace. @type sep: str or None @keyword spin_id: The spin ID string. @type spin_id: None or str """ # Test if the current pipe exists. check_pipe() # Test if sequence data is loaded. if not exists_mol_res_spin_data(): raise RelaxNoSequenceError # Minimisation statistic flag. min_stat = False # Alias specific analysis API object method. api = return_api() return_value = api.return_value # Specific set function. set_fn = set # Test data corresponding to param already exists. for spin in spin_loop(): # Skip deselected spins. if not spin.select: continue # Get the value and error. value, error = return_value(spin, param) # Data exists. if value != None or error != None: raise RelaxValueError(param) # Loop over the data. mol_names = [] res_nums = [] res_names = [] spin_nums = [] spin_names = [] values = [] errors = [] for data in read_spin_data(file=file, dir=dir, file_data=file_data, spin_id_col=spin_id_col, mol_name_col=mol_name_col, res_num_col=res_num_col, res_name_col=res_name_col, spin_num_col=spin_num_col, spin_name_col=spin_name_col, data_col=data_col, error_col=error_col, sep=sep, spin_id=spin_id): # Unpack. if data_col and error_col: mol_name, res_num, res_name, spin_num, spin_name, value, error = data elif data_col: mol_name, res_num, res_name, spin_num, spin_name, value = data error = None else: mol_name, res_num, res_name, spin_num, spin_name, error = data value = None # Set the value. id = generate_spin_id_unique(mol_name=mol_name, res_num=res_num, res_name=res_name, spin_num=spin_num, spin_name=spin_name) set_fn(val=value, error=error, param=param, spin_id=id) # Append the data for printout. mol_names.append(mol_name) res_nums.append(res_num) res_names.append(res_name) spin_nums.append(spin_num) spin_names.append(spin_name) values.append(value) errors.append(error) # Print out. write_spin_data(file=sys.stdout, mol_names=mol_names, res_nums=res_nums, res_names=res_names, spin_nums=spin_nums, spin_names=spin_names, data=values, data_name=param, error=errors, error_name='%s_error'%param) # Reset the minimisation statistics. if api.set(param) == 'min': minimise.reset_min_stats()
def copy(pipe_from=None, pipe_to=None, param=None): """Copy spin specific data values from pipe_from to pipe_to. @param pipe_from: The data pipe to copy the value from. This defaults to the current data pipe. @type pipe_from: str @param pipe_to: The data pipe to copy the value to. This defaults to the current data pipe. @type pipe_to: str @param param: The name of the parameter to copy the values of. @type param: str """ # The current data pipe. if pipe_from == None: pipe_from = pipes.cdp_name() if pipe_to == None: pipe_to = pipes.cdp_name() pipe_orig = pipes.cdp_name() # The second pipe does not exist. pipes.test(pipe_to) # Test if the sequence data for pipe_from is loaded. if not exists_mol_res_spin_data(pipe_from): raise RelaxNoSequenceError(pipe_from) # Test if the sequence data for pipe_to is loaded. if not exists_mol_res_spin_data(pipe_to): raise RelaxNoSequenceError(pipe_to) # Specific value and error returning function. return_value = specific_analyses.setup.get_specific_fn('return_value', pipes.get_type(pipe_from)) # Test if the data exists for pipe_to. for spin in spin_loop(pipe=pipe_to): # Get the value and error for pipe_to. value, error = return_value(spin, param) # Data exists. if value != None or error != None: raise RelaxValueError(param, pipe_to) # Switch to the data pipe to copy values to. pipes.switch(pipe_to) # Copy the values. for spin, spin_id in spin_loop(pipe=pipe_from, return_id=True): # Get the value and error from pipe_from. value, error = return_value(spin, param) # Set the values of pipe_to. if value != None: set(spin_id=spin_id, val=value, param=param, pipe=pipe_to) if error != None: set(spin_id=spin_id, val=error, param=param, pipe=pipe_to, error=True) # Reset all minimisation statistics. minimise.reset_min_stats(pipe_to) # Switch back to the original current data pipe. pipes.switch(pipe_orig)