def catia_input(file='Fit.catia', dir=None, output_dir='output', force=False): """Create the CATIA input files. @keyword file: The main CATIA execution file. @type file: str @keyword dir: The optional directory to place the files into. If None, then the files will be placed into the current directory. @type dir: str or None @keyword output_dir: The CATIA output directory, located within the directory specified by the dir argument. This directory will be created. @type output_dir: str @keyword force: A flag which if True will cause all pre-existing files to be overwritten. @type force: Bool """ # Data checks. check_pipe() check_mol_res_spin_data() check_spectra_id_setup() check_model_type() # Check that this is CPMG data. for id in cdp.spectrum_ids: if cdp.exp_type[id] != 'SQ CPMG': raise RelaxError("Only CPMG type data is supported.") # Directory creation. if dir != None: mkdir_nofail(dir, verbosity=0) # Create the R2eff files. write_r2eff_files(input_dir='input_r2eff', base_dir=dir, force=force) # Create the parameter files. write_param_files(global_file="ParamGlobal.inp", set_file="ParamSet1.inp", dir=dir, force=force) # Create the main execution file. write_main_file(file=file, dir=dir, output_dir=output_dir, force=force) # Create the output directory as needed by CATIA (it does not create it itself). mkdir_nofail(dir + sep + output_dir, verbosity=0)
def catia_input(file='Fit.catia', dir=None, output_dir='output', force=False): """Create the CATIA input files. @keyword file: The main CATIA execution file. @type file: str @keyword dir: The optional directory to place the files into. If None, then the files will be placed into the current directory. @type dir: str or None @keyword output_dir: The CATIA output directory, located within the directory specified by the dir argument. This directory will be created. @type output_dir: str @keyword force: A flag which if True will cause all pre-existing files to be overwritten. @type force: Bool """ # Data checks. pipes.test() check_mol_res_spin_data() check_spectra_id_setup() check_model_type() # Check that this is CPMG data. for id in cdp.spectrum_ids: if cdp.exp_type[id] != 'SQ CPMG': raise RelaxError("Only CPMG type data is supported.") # Directory creation. if dir != None: mkdir_nofail(dir, verbosity=0) # Create the R2eff files. write_r2eff_files(input_dir='input_r2eff', base_dir=dir, force=force) # Create the parameter files. write_param_files(global_file="ParamGlobal.inp", set_file="ParamSet1.inp", dir=dir, force=force) # Create the main execution file. write_main_file(file=file, dir=dir, output_dir=output_dir, force=force) # Create the output directory as needed by CATIA (it does not create it itself). mkdir_nofail(dir + sep + output_dir, verbosity=0)
def estimate_r2eff(method='minfx', min_algor='simplex', c_code=True, constraints=False, chi2_jacobian=False, spin_id=None, ftol=1e-15, xtol=1e-15, maxfev=10000000, factor=100.0, verbosity=1): """Estimate r2eff and errors by exponential curve fitting with scipy.optimize.leastsq or minfx. THIS IS ONLY FOR TESTING. scipy.optimize.leastsq is a wrapper around MINPACK's lmdif and lmder algorithms. MINPACK is a FORTRAN90 library which solves systems of nonlinear equations, or carries out the least squares minimization of the residual of a set of linear or nonlinear equations. Errors are calculated by taking the square root of the reported co-variance. This can be an huge time saving step, when performing model fitting in R1rho. Errors of R2eff values, are normally estimated by time-consuming Monte-Carlo simulations. Initial guess for the starting parameter x0 = [r2eff_est, i0_est], is by converting the exponential curve to a linear problem. Then solving initial guess by linear least squares of: ln(Intensity[j]) = ln(i0) - time[j]* r2eff. @keyword method: The method to minimise and estimate errors. Options are: 'minfx' or 'scipy.optimize.leastsq'. @type method: string @keyword min_algor: The minimisation algorithm @type min_algor: string @keyword c_code: If optimise with C code. @type c_code: bool @keyword constraints: If constraints should be used. @type constraints: bool @keyword chi2_jacobian: If the chi2 Jacobian should be used. @type chi2_jacobian: bool @keyword spin_id: The spin identification string. @type spin_id: str @keyword ftol: The function tolerance for the relative error desired in the sum of squares, parsed to leastsq. @type ftol: float @keyword xtol: The error tolerance for the relative error desired in the approximate solution, parsed to leastsq. @type xtol: float @keyword maxfev: The maximum number of function evaluations, parsed to leastsq. If zero, then 100*(N+1) is the maximum function calls. N is the number of elements in x0=[r2eff, i0]. @type maxfev: int @keyword factor: The initial step bound, parsed to leastsq. It determines the initial step bound (''factor * || diag * x||''). Should be in the interval (0.1, 100). @type factor: float @keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int """ # Perform checks. check_model_type(model=MODEL_R2EFF) # Check that the C modules have been compiled. if not C_module_exp_fn and method == 'minfx': raise RelaxError( "Relaxation curve fitting is not available. Try compiling the C modules on your platform." ) # Set class scipy setting. E = Exp(verbosity=verbosity) E.set_settings_leastsq(ftol=ftol, xtol=xtol, maxfev=maxfev, factor=factor) # Check if intensity errors have already been calculated by the user. precalc = True for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop( selection=spin_id, full_info=True, return_id=True, skip_desel=True): # No structure. if not hasattr(cur_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 cur_spin.peak_intensity_err: precalc = False break # Loop over the spins. for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop( selection=spin_id, full_info=True, return_id=True, skip_desel=True): # Generate spin string. spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn) # Print information. if E.verbosity >= 1: # Individual spin block section. top = 2 if E.verbosity >= 2: top += 2 subsection(file=sys.stdout, text="Fitting with %s to: %s" % (method, spin_string), prespace=top) if method == 'minfx': subsection( file=sys.stdout, text= "min_algor='%s', c_code=%s, constraints=%s, chi2_jacobian?=%s" % (min_algor, c_code, constraints, chi2_jacobian), prespace=0) # Loop over each spectrometer frequency and dispersion point. for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point( return_indices=True): # The parameter key. param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point) # The peak intensities, errors and times. values = [] errors = [] times = [] for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point): values.append( average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time)) errors.append( average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True)) times.append(time) # Convert to numpy array. values = asarray(values) errors = asarray(errors) times = asarray(times) # Initialise data. E.setup_data(values=values, errors=errors, times=times) # Get the result based on method. if method == 'scipy.optimize.leastsq': # Acquire results. results = minimise_leastsq(E=E) elif method == 'minfx': # Set settings. E.set_settings_minfx(min_algor=min_algor, c_code=c_code, chi2_jacobian=chi2_jacobian, constraints=constraints) # Acquire results. results = minimise_minfx(E=E) else: raise RelaxError( "Method for minimisation not known. Try setting: method='scipy.optimize.leastsq'." ) # Unpack results param_vector, param_vector_error, chi2, iter_count, f_count, g_count, h_count, warning = results # Extract values. r2eff = param_vector[0] i0 = param_vector[1] r2eff_err = param_vector_error[0] i0_err = param_vector_error[1] # Disassemble the parameter vector. disassemble_param_vector(param_vector=param_vector, spins=[cur_spin], key=param_key) # Errors. if not hasattr(cur_spin, 'r2eff_err'): setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff'))) if not hasattr(cur_spin, 'i0_err'): setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0'))) # Set error. cur_spin.r2eff_err[param_key] = r2eff_err cur_spin.i0_err[param_key] = i0_err # Chi-squared statistic. cur_spin.chi2 = chi2 # Iterations. cur_spin.f_count = f_count # Warning. cur_spin.warning = warning # Print information. print_strings = [] if E.verbosity >= 1: # Add print strings. point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % ( exp_type, frq / 1E6, offset, point, len(times)) print_strings.append(point_info) par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2) print_strings.append(par_info) if E.verbosity >= 2: time_info = ', '.join(map(str, times)) print_strings.append('For time array: ' + time_info + '.\n\n') # Print info if len(print_strings) > 0: for print_string in print_strings: print(print_string),
def estimate_r2eff_err(spin_id=None, epsrel=0.0, verbosity=1): """This will estimate the R2eff and i0 errors from the covariance matrix Qxx. Qxx is calculated from the Jacobian matrix and the optimised parameters. @keyword spin_id: The spin identification string. @type spin_id: str @param epsrel: Any columns of R which satisfy |R_{kk}| <= epsrel |R_{11}| are considered linearly-dependent and are excluded from the covariance matrix, where the corresponding rows and columns of the covariance matrix are set to zero. @type epsrel: float @keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int """ # Check that the C modules have been compiled. if not C_module_exp_fn: raise RelaxError( "Relaxation curve fitting is not available. Try compiling the C modules on your platform." ) # Perform checks. check_model_type(model=MODEL_R2EFF) # Loop over the spins. for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop( selection=spin_id, full_info=True, return_id=True, skip_desel=True): # Generate spin string. spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn) # Raise Error, if not optimised. if not (hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'i0')): raise RelaxError( "Spin %s does not contain optimised 'r2eff' and 'i0' values. Try execute: minimise.execute(min_algor='Newton', constraints=False)" % (spin_string)) # Raise warning, if gradient count is 0. This could point to a lack of minimisation first. if hasattr(cur_spin, 'g_count'): if getattr(cur_spin, 'g_count') == 0.0: text = "Spin %s contains a gradient count of 0.0. Is the R2eff parameter optimised? Try execute: minimise.execute(min_algor='Newton', constraints=False)" % ( spin_string) warn(RelaxWarning("%s." % text)) # Print information. if verbosity >= 1: # Individual spin block section. top = 2 if verbosity >= 2: top += 2 subsection(file=sys.stdout, text="Estimating R2eff error for spin: %s" % spin_string, prespace=top) # Loop over each spectrometer frequency and dispersion point. for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point( return_indices=True): # The parameter key. param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point) # Extract values. r2eff = getattr(cur_spin, 'r2eff')[param_key] i0 = getattr(cur_spin, 'i0')[param_key] # Pack data param_vector = [r2eff, i0] # The peak intensities, errors and times. values = [] errors = [] times = [] for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point): values.append( average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time)) errors.append( average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True)) times.append(time) # Convert to numpy array. values = asarray(values) errors = asarray(errors) times = asarray(times) # Initialise data in C code. scaling_list = [1.0, 1.0] model = Relax_fit_opt(model='exp', num_params=len(param_vector), values=values, errors=errors, relax_times=times, scaling_matrix=scaling_list) # Use the direct Jacobian from function. jacobian_matrix_exp = transpose( asarray(model.jacobian(param_vector))) weights = 1. / errors**2 # Get the co-variance pcov = multifit_covar(J=jacobian_matrix_exp, weights=weights) # To compute one standard deviation errors on the parameters, take the square root of the diagonal covariance. param_vector_error = sqrt(diag(pcov)) # Extract values. r2eff_err, i0_err = param_vector_error # Copy r2eff dictionary, to r2eff_err dictionary. They have same keys to the dictionary, if not hasattr(cur_spin, 'r2eff_err'): setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff'))) if not hasattr(cur_spin, 'i0_err'): setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0'))) # Set error. cur_spin.r2eff_err[param_key] = r2eff_err cur_spin.i0_err[param_key] = i0_err # Get other relevant information. chi2 = getattr(cur_spin, 'chi2') # Print information. print_strings = [] if verbosity >= 1: # Add print strings. point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % ( exp_type, frq / 1E6, offset, point, len(times)) print_strings.append(point_info) par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2) print_strings.append(par_info) if verbosity >= 2: time_info = ', '.join(map(str, times)) print_strings.append('For time array: ' + time_info + '.\n\n') # Print info if len(print_strings) > 0: for print_string in print_strings: print(print_string),
def estimate_r2eff_err(spin_id=None, epsrel=0.0, verbosity=1): """This will estimate the R2eff and i0 errors from the covariance matrix Qxx. Qxx is calculated from the Jacobian matrix and the optimised parameters. @keyword spin_id: The spin identification string. @type spin_id: str @param epsrel: Any columns of R which satisfy |R_{kk}| <= epsrel |R_{11}| are considered linearly-dependent and are excluded from the covariance matrix, where the corresponding rows and columns of the covariance matrix are set to zero. @type epsrel: float @keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int """ # Check that the C modules have been compiled. if not C_module_exp_fn: raise RelaxError("Relaxation curve fitting is not available. Try compiling the C modules on your platform.") # Perform checks. check_model_type(model=MODEL_R2EFF) # Loop over the spins. for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True): # Generate spin string. spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn) # Raise Error, if not optimised. if not (hasattr(cur_spin, 'r2eff') and hasattr(cur_spin, 'i0')): raise RelaxError("Spin %s does not contain optimised 'r2eff' and 'i0' values. Try execute: minimise.execute(min_algor='Newton', constraints=False)"%(spin_string)) # Raise warning, if gradient count is 0. This could point to a lack of minimisation first. if hasattr(cur_spin, 'g_count'): if getattr(cur_spin, 'g_count') == 0.0: text = "Spin %s contains a gradient count of 0.0. Is the R2eff parameter optimised? Try execute: minimise.execute(min_algor='Newton', constraints=False)" %(spin_string) warn(RelaxWarning("%s." % text)) # Print information. if verbosity >= 1: # Individual spin block section. top = 2 if verbosity >= 2: top += 2 subsection(file=sys.stdout, text="Estimating R2eff error for spin: %s"%spin_string, prespace=top) # Loop over each spectrometer frequency and dispersion point. for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(return_indices=True): # The parameter key. param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point) # Extract values. r2eff = getattr(cur_spin, 'r2eff')[param_key] i0 = getattr(cur_spin, 'i0')[param_key] # Pack data param_vector = [r2eff, i0] # The peak intensities, errors and times. values = [] errors = [] times = [] for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point): values.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time)) errors.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True)) times.append(time) # Convert to numpy array. values = asarray(values) errors = asarray(errors) times = asarray(times) # Initialise data in C code. scaling_list = [1.0, 1.0] model = Relax_fit_opt(model='exp', num_params=len(param_vector), values=values, errors=errors, relax_times=times, scaling_matrix=scaling_list) # Use the direct Jacobian from function. jacobian_matrix_exp = transpose(asarray( model.jacobian(param_vector) ) ) weights = 1. / errors**2 # Get the co-variance pcov = multifit_covar(J=jacobian_matrix_exp, weights=weights) # To compute one standard deviation errors on the parameters, take the square root of the diagonal covariance. param_vector_error = sqrt(diag(pcov)) # Extract values. r2eff_err, i0_err = param_vector_error # Copy r2eff dictionary, to r2eff_err dictionary. They have same keys to the dictionary, if not hasattr(cur_spin, 'r2eff_err'): setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff'))) if not hasattr(cur_spin, 'i0_err'): setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0'))) # Set error. cur_spin.r2eff_err[param_key] = r2eff_err cur_spin.i0_err[param_key] = i0_err # Get other relevant information. chi2 = getattr(cur_spin, 'chi2') # Print information. print_strings = [] if verbosity >= 1: # Add print strings. point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (exp_type, frq/1E6, offset, point, len(times)) print_strings.append(point_info) par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2) print_strings.append(par_info) if verbosity >= 2: time_info = ', '.join(map(str, times)) print_strings.append('For time array: '+time_info+'.\n\n') # Print info if len(print_strings) > 0: for print_string in print_strings: print(print_string),
def estimate_r2eff(method='minfx', min_algor='simplex', c_code=True, constraints=False, chi2_jacobian=False, spin_id=None, ftol=1e-15, xtol=1e-15, maxfev=10000000, factor=100.0, verbosity=1): """Estimate r2eff and errors by exponential curve fitting with scipy.optimize.leastsq or minfx. THIS IS ONLY FOR TESTING. scipy.optimize.leastsq is a wrapper around MINPACK's lmdif and lmder algorithms. MINPACK is a FORTRAN90 library which solves systems of nonlinear equations, or carries out the least squares minimization of the residual of a set of linear or nonlinear equations. Errors are calculated by taking the square root of the reported co-variance. This can be an huge time saving step, when performing model fitting in R1rho. Errors of R2eff values, are normally estimated by time-consuming Monte-Carlo simulations. Initial guess for the starting parameter x0 = [r2eff_est, i0_est], is by converting the exponential curve to a linear problem. Then solving initial guess by linear least squares of: ln(Intensity[j]) = ln(i0) - time[j]* r2eff. @keyword method: The method to minimise and estimate errors. Options are: 'minfx' or 'scipy.optimize.leastsq'. @type method: string @keyword min_algor: The minimisation algorithm @type min_algor: string @keyword c_code: If optimise with C code. @type c_code: bool @keyword constraints: If constraints should be used. @type constraints: bool @keyword chi2_jacobian: If the chi2 Jacobian should be used. @type chi2_jacobian: bool @keyword spin_id: The spin identification string. @type spin_id: str @keyword ftol: The function tolerance for the relative error desired in the sum of squares, parsed to leastsq. @type ftol: float @keyword xtol: The error tolerance for the relative error desired in the approximate solution, parsed to leastsq. @type xtol: float @keyword maxfev: The maximum number of function evaluations, parsed to leastsq. If zero, then 100*(N+1) is the maximum function calls. N is the number of elements in x0=[r2eff, i0]. @type maxfev: int @keyword factor: The initial step bound, parsed to leastsq. It determines the initial step bound (''factor * || diag * x||''). Should be in the interval (0.1, 100). @type factor: float @keyword verbosity: The amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int """ # Perform checks. check_model_type(model=MODEL_R2EFF) # Check that the C modules have been compiled. if not C_module_exp_fn and method == 'minfx': raise RelaxError("Relaxation curve fitting is not available. Try compiling the C modules on your platform.") # Set class scipy setting. E = Exp(verbosity=verbosity) E.set_settings_leastsq(ftol=ftol, xtol=xtol, maxfev=maxfev, factor=factor) # Check if intensity errors have already been calculated by the user. precalc = True for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True): # No structure. if not hasattr(cur_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 cur_spin.peak_intensity_err: precalc = False break # Loop over the spins. for cur_spin, mol_name, resi, resn, cur_spin_id in spin_loop(selection=spin_id, full_info=True, return_id=True, skip_desel=True): # Generate spin string. spin_string = generate_spin_string(spin=cur_spin, mol_name=mol_name, res_num=resi, res_name=resn) # Print information. if E.verbosity >= 1: # Individual spin block section. top = 2 if E.verbosity >= 2: top += 2 subsection(file=sys.stdout, text="Fitting with %s to: %s"%(method, spin_string), prespace=top) if method == 'minfx': subsection(file=sys.stdout, text="min_algor='%s', c_code=%s, constraints=%s, chi2_jacobian?=%s"%(min_algor, c_code, constraints, chi2_jacobian), prespace=0) # Loop over each spectrometer frequency and dispersion point. for exp_type, frq, offset, point, ei, mi, oi, di in loop_exp_frq_offset_point(return_indices=True): # The parameter key. param_key = return_param_key_from_data(exp_type=exp_type, frq=frq, offset=offset, point=point) # The peak intensities, errors and times. values = [] errors = [] times = [] for time in loop_time(exp_type=exp_type, frq=frq, offset=offset, point=point): values.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time)) errors.append(average_intensity(spin=cur_spin, exp_type=exp_type, frq=frq, offset=offset, point=point, time=time, error=True)) times.append(time) # Convert to numpy array. values = asarray(values) errors = asarray(errors) times = asarray(times) # Initialise data. E.setup_data(values=values, errors=errors, times=times) # Get the result based on method. if method == 'scipy.optimize.leastsq': # Acquire results. results = minimise_leastsq(E=E) elif method == 'minfx': # Set settings. E.set_settings_minfx(min_algor=min_algor, c_code=c_code, chi2_jacobian=chi2_jacobian, constraints=constraints) # Acquire results. results = minimise_minfx(E=E) else: raise RelaxError("Method for minimisation not known. Try setting: method='scipy.optimize.leastsq'.") # Unpack results param_vector, param_vector_error, chi2, iter_count, f_count, g_count, h_count, warning = results # Extract values. r2eff = param_vector[0] i0 = param_vector[1] r2eff_err = param_vector_error[0] i0_err = param_vector_error[1] # Disassemble the parameter vector. disassemble_param_vector(param_vector=param_vector, spins=[cur_spin], key=param_key) # Errors. if not hasattr(cur_spin, 'r2eff_err'): setattr(cur_spin, 'r2eff_err', deepcopy(getattr(cur_spin, 'r2eff'))) if not hasattr(cur_spin, 'i0_err'): setattr(cur_spin, 'i0_err', deepcopy(getattr(cur_spin, 'i0'))) # Set error. cur_spin.r2eff_err[param_key] = r2eff_err cur_spin.i0_err[param_key] = i0_err # Chi-squared statistic. cur_spin.chi2 = chi2 # Iterations. cur_spin.f_count = f_count # Warning. cur_spin.warning = warning # Print information. print_strings = [] if E.verbosity >= 1: # Add print strings. point_info = "%s at %3.1f MHz, for offset=%3.3f ppm and dispersion point %-5.1f, with %i time points." % (exp_type, frq/1E6, offset, point, len(times)) print_strings.append(point_info) par_info = "r2eff=%3.3f r2eff_err=%3.4f, i0=%6.1f, i0_err=%3.4f, chi2=%3.3f.\n" % ( r2eff, r2eff_err, i0, i0_err, chi2) print_strings.append(par_info) if E.verbosity >= 2: time_info = ', '.join(map(str, times)) print_strings.append('For time array: '+time_info+'.\n\n') # Print info if len(print_strings) > 0: for print_string in print_strings: print(print_string),