class Stereochem_analysis:
"""Class for performing the relative stereochemistry analysis."""
def __init__(self, stage=1, results_dir=None, num_ens=10000, num_models=10, configs=None, snapshot_dir='snapshots', snapshot_min=None, snapshot_max=None, pseudo=None, noe_file=None, noe_norm=None, rdc_name=None, rdc_file=None, rdc_spin_id1_col=None, rdc_spin_id2_col=None, rdc_data_col=None, rdc_error_col=None, bond_length=None, bond_length_file=None, log=None, bucket_num=200, lower_lim_noe=0.0, upper_lim_noe=600.0, lower_lim_rdc=0.0, upper_lim_rdc=1.0):
"""Set up for the stereochemistry analysis.
@keyword stage: Stage of analysis (see the module docstring above for the options).
@type stage: int
@keyword results_dir: The optional directory to place all results files into.
@type results_dir: None or str
@keyword num_ens: Number of ensembles.
@type num_ens: int
@keyword num_models: Ensemble size.
@type num_models: int
@keyword configs: All the configurations.
@type configs: list of str
@keyword snapshot_dir: Snapshot directories (corresponding to the configurations).
@type snapshot_dir: list of str
@keyword snapshot_min: The number of the first snapshots (corresponding to the configurations).
@type snapshot_min: list of int
@keyword snapshot_max: The number of the last snapshots (corresponding to the configurations).
@type snapshot_max: list of int
@keyword pseudo: The list of pseudo-atoms. Each element is a list of the pseudo-atom name and a list of all those atoms forming the pseudo-atom. For example, pseudo = [["Q7", ["@H16", "@H17", "@H18"]], ["Q9", ["@H20", "@H21", "@H22"]]].
@type pseudo: list of list of str and list of str
@keyword noe_file: The name of the NOE restraint file.
@type noe_file: str
@keyword noe_norm: The NOE normalisation factor (equal to the sum of all NOEs squared).
@type noe_norm: float
@keyword rdc_name: The label for this RDC data set.
@type rdc_name: str
@keyword rdc_file: The name of the RDC file.
@type rdc_file: str
@keyword rdc_spin_id1_col: The spin ID column of the first spin in the RDC file.
@type rdc_spin_id1_col: None or int
@keyword rdc_spin_id2_col: The spin ID column of the second spin in the RDC file.
@type rdc_spin_id2_col: None or int
@keyword rdc_data_col: The data column of the RDC file.
@type rdc_data_col: int
@keyword rdc_error_col: The error column of the RDC file.
@type rdc_error_col: int
@keyword bond_length: The bond length value in meters. This overrides the bond_length_file argument.
@type bond_length: float or None
@keyword bond_length_file: The file of bond lengths for each atom pair in meters. The first and second columns must be the spin ID strings and the third column must contain the data.
@type bond_length_file: float or None
@keyword log: Log file output flag (only for certain stages).
@type log: bool
@keyword bucket_num: Number of buckets for the distribution plots.
@type bucket_num: int
@keyword lower_lim_noe: Distribution plot limits.
@type lower_lim_noe: int
@keyword upper_lim_noe: Distribution plot limits.
@type upper_lim_noe: int
@keyword lower_lim_rdc: Distribution plot limits.
@type lower_lim_rdc: int
@keyword upper_lim_rdc: Distribution plot limits.
@type upper_lim_rdc: int
"""
# Execution lock.
status.exec_lock.acquire('auto stereochem analysis', mode='auto-analysis')
# Set up the analysis status object.
status.init_auto_analysis('stereochem', type='stereochem')
status.current_analysis = 'auto stereochem analysis'
# Store all the args.
self.stage = stage
self.results_dir = results_dir
self.num_ens = num_ens
self.num_models = num_models
self.configs = configs
self.snapshot_dir = snapshot_dir
self.snapshot_min = snapshot_min
self.snapshot_max = snapshot_max
self.pseudo = pseudo
self.noe_file = noe_file
self.noe_norm = noe_norm
self.rdc_name = rdc_name
self.rdc_file = rdc_file
self.rdc_spin_id1_col = rdc_spin_id1_col
self.rdc_spin_id2_col = rdc_spin_id2_col
self.rdc_data_col = rdc_data_col
self.rdc_error_col = rdc_error_col
self.bond_length = bond_length
self.bond_length_file = bond_length_file
self.log = log
self.bucket_num = bucket_num
self.lower_lim_noe = lower_lim_noe
self.upper_lim_noe = upper_lim_noe
self.lower_lim_rdc = lower_lim_rdc
self.upper_lim_rdc = upper_lim_rdc
# Load the interpreter.
self.interpreter = Interpreter(show_script=False, quit=False, raise_relax_error=True)
self.interpreter.populate_self()
self.interpreter.on(verbose=False)
# Create the results directory.
if self.results_dir:
mkdir_nofail(self.results_dir)
# Or use the current working directory.
else:
self.results_dir = getcwd()
# Create a directory for log files.
if self.log:
mkdir_nofail(self.results_dir + sep + "logs")
# Finish and unlock execution.
status.auto_analysis['stereochem'].fin = True
status.current_analysis = None
status.exec_lock.release()
def run(self):
"""Execute the given stage of the analysis."""
# Store the original STDOUT.
self.stdout_orig = sys.stdout
# Sampling of snapshots.
if self.stage == 1:
self.sample()
# NOE violation analysis.
elif self.stage == 2:
self.noe_viol()
# Ensemble superimposition.
elif self.stage == 3:
self.superimpose()
# RDC Q-factor analysis.
elif self.stage == 4:
self.rdc_analysis()
# Grace plot creation.
elif self.stage == 5:
self.grace_plots()
# Final combined Q ordering.
elif self.stage == 6:
self.combined_q()
# Unknown stage.
else:
raise RelaxError("The stage number %s is unknown." % self.stage)
# Restore STDOUT.
sys.stdout = self.stdout_orig
def combined_q(self):
"""Calculate the combined Q-factor.
The combined Q is defined as::
Q_total^2 = Q_NOE^2 + Q_RDC^2,
and the NOE Q-factor as::
Q^2 = U / sum(NOE_i^2),
where U is the quadratic flat bottom well potential - the NOE violation in Angstrom^2.
"""
# Checks.
if not access(self.results_dir+sep+"NOE_viol_" + self.configs[0] + "_sorted", F_OK):
raise RelaxError("The NOE analysis has not been performed, cannot find the file '%s'." % self.results_dir+sep+"NOE_viol_" + self.configs[0] + "_sorted")
if not access(self.results_dir+sep+"Q_factors_" + self.configs[0] + "_sorted", F_OK):
raise RelaxError("The RDC analysis has not been performed, cannot find the file '%s'." % self.results_dir+sep+"Q_factors_" + self.configs[0] + "_sorted")
# Loop over the configurations.
for i in range(len(self.configs)):
# Print out.
print("Creating the combined Q-factor file for configuration '%s'." % self.configs[i])
# Open the NOE results file and read the data.
file = open(self.results_dir+sep+"NOE_viol_" + self.configs[i])
noe_lines = file.readlines()
file.close()
# Open the RDC results file and read the data.
file = open(self.results_dir+sep+"Q_factors_" + self.configs[i])
rdc_lines = file.readlines()
file.close()
# The combined Q-factor file.
out = open(self.results_dir+sep+"Q_total_%s" % self.configs[i], 'w')
out_sorted = open(self.results_dir+sep+"Q_total_%s_sorted" % self.configs[i], 'w')
# Loop over the data (skipping the header line).
data = []
for j in range(1, len(noe_lines)):
# Split the lines.
ens = int(noe_lines[j].split()[0])
noe_viol = float(noe_lines[j].split()[1])
q_rdc = float(rdc_lines[j].split()[1])
# The NOE Q-factor.
q_noe = sqrt(noe_viol/self.noe_norm)
# Combined Q.
q = sqrt(q_noe**2 + q_rdc**2)
# Write out the unsorted list.
out.write("%-20i%20.15f\n" % (ens, q))
# Store the values.
data.append([q, ens])
# Sort the combined Q.
data.sort()
# Write the data.
for i in range(len(data)):
out_sorted.write("%-20i%20.15f\n" % (data[i][1], data[i][0]))
# Close the files.
out.close()
out_sorted.close()
def generate_distribution(self, values, lower=0.0, upper=200.0, inc=None):
"""Create the distribution data structure."""
# The bin width.
bin_width = (upper - lower)/float(inc)
# Init the dist object.
dist = []
for i in range(inc):
dist.append([bin_width*i+lower, 0])
# Loop over the values.
for val in values:
# The bin.
bin = int((val - lower)/bin_width)
# Outside of the limits.
if bin < 0 or bin >= inc:
print("Outside of the limits: '%s'" % val)
continue
# Increment the count.
dist[bin][1] = dist[bin][1] + 1
# Convert the counts to frequencies.
total_pr = 0.0
for i in range(inc):
dist[i][1] = dist[i][1] / float(len(values))
total_pr = total_pr + dist[i][1]
print("Total Pr: %s" % total_pr)
# Return the dist.
return dist
def grace_plots(self):
"""Generate grace plots of the results."""
# The number of configs.
n = len(self.configs)
# The colours for the different configs.
defaults = [4, 2] # Blue and red.
colours = []
for i in range(n):
# Default colours.
if i < len(defaults):
colours.append(defaults[i])
# Otherwise black!
else:
colours.append(0)
# The ensemble number text.
ens_text = ''
dividers = [1e15, 1e12, 1e9, 1e6, 1e3, 1]
num_ens = self.num_ens
for i in range(len(dividers)):
# The number.
num = int(num_ens / dividers[i])
# The text.
if num:
text = repr(num)
elif not num and ens_text:
text = '000'
else:
continue
# Update the text.
ens_text = ens_text + text
# A comma.
if i < len(dividers)-1:
ens_text = ens_text + ','
# Remove the front part of the number.
num_ens = num_ens - dividers[i]*num
# Subtitle for all graphs.
subtitle = '%s ensembles of %s' % (ens_text, self.num_models)
# NOE violations.
if access(self.results_dir+sep+"NOE_viol_" + self.configs[0] + "_sorted", F_OK):
# Print out.
print("Generating NOE violation Grace plots.")
# Open the output files.
grace_curve = open(self.results_dir+sep+"NOE_viol_curve.agr", 'w')
grace_dist = open(self.results_dir+sep+"NOE_viol_dist.agr", 'w')
# Loop over the configurations.
data = []
dist = []
for i in range(n):
# Open the results file and read the data.
file = open(self.results_dir+sep+"NOE_viol_" + self.configs[i] + "_sorted")
lines = file.readlines()
file.close()
# Add a new graph set.
data.append([])
# Loop over the ensembles and extract the NOE violation.
noe_viols = []
for j in range(1, len(lines)):
# Extract the violation.
viol = float(lines[j].split()[1])
noe_viols.append(viol)
# Add to the data structure.
data[i].append([j, viol])
# Calculate the R distribution.
dist.append(self.generate_distribution(noe_viols, inc=self.bucket_num, upper=self.upper_lim_noe, lower=self.lower_lim_noe))
# Headers.
write_xy_header(file=grace_curve, title='NOE violation comparison', subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[0]*n], axis_labels=[['Ensemble (sorted)', 'NOE violation (Angstrom\\S2\\N)']], legend_pos=[[0.3, 0.8]])
write_xy_header(file=grace_dist, title='NOE violation comparison', subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[1]*n], symbol_sizes=[[0.5]*n], linestyle=[[3]*n], axis_labels=[['NOE violation (Angstrom\\S2\\N)', 'Frequency']], legend_pos=[[1.1, 0.8]])
# Write the data.
write_xy_data([data], file=grace_curve, graph_type='xy')
write_xy_data([dist], file=grace_dist, graph_type='xy')
# Close the files.
grace_curve.close()
grace_dist.close()
# RDC Q-factors.
if access(self.results_dir+sep+"Q_factors_" + self.configs[0] + "_sorted", F_OK):
# Print out.
print("Generating RDC Q-factor Grace plots.")
# Open the Grace output files.
grace_curve = open(self.results_dir+sep+"RDC_%s_curve.agr" % self.rdc_name, 'w')
grace_dist = open(self.results_dir+sep+"RDC_%s_dist.agr" % self.rdc_name, 'w')
# Loop over the configurations.
data = []
dist = []
for i in range(n):
# Open the results file and read the data.
file = open(self.results_dir+sep+"Q_factors_" + self.configs[i] + "_sorted")
lines = file.readlines()
file.close()
# Add a new graph set.
data.append([])
# Loop over the Q-factors.
values = []
for j in range(1, len(lines)):
# Extract the violation.
value = float(lines[j].split()[1])
values.append(value)
# Add to the data structure.
data[i].append([j, value])
# Calculate the R distribution.
dist.append(self.generate_distribution(values, inc=self.bucket_num, upper=self.upper_lim_rdc, lower=self.lower_lim_rdc))
# Headers.
write_xy_header(file=grace_curve, title='%s RDC Q-factor comparison' % self.rdc_name, subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[0]*n], axis_labels=[['Ensemble (sorted)', '%s RDC Q-factor (pales format)' % self.rdc_name]], legend_pos=[[0.3, 0.8]])
write_xy_header(file=grace_dist, title='%s RDC Q-factor comparison' % self.rdc_name, subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[1]*n], symbol_sizes=[[0.5]*n], linestyle=[[3]*n], axis_labels=[['%s RDC Q-factor (pales format)' % self.rdc_name, 'Frequency']], legend_pos=[[1.1, 0.8]])
# Write the data.
write_xy_data([data], file=grace_curve, graph_type='xy')
write_xy_data([dist], file=grace_dist, graph_type='xy')
# Close the files.
grace_curve.close()
grace_dist.close()
# NOE-RDC correlation plots.
if access(self.results_dir+sep+"NOE_viol_" + self.configs[0] + "_sorted", F_OK) and access(self.results_dir+sep+"Q_factors_" + self.configs[0] + "_sorted", F_OK):
# Print out.
print("Generating NOE-RDC correlation Grace plots.")
# Open the Grace output files.
grace_file = open(self.results_dir+sep+"correlation_plot.agr", 'w')
grace_file_scaled = open(self.results_dir+sep+"correlation_plot_scaled.agr", 'w')
# Grace data.
data = []
data_scaled = []
for i in range(len(self.configs)):
# Open the NOE results file and read the data.
file = open(self.results_dir+sep+"NOE_viol_" + self.configs[i])
noe_lines = file.readlines()
file.close()
# Add a new graph set.
data.append([])
data_scaled.append([])
# Open the RDC results file and read the data.
file = open(self.results_dir+sep+"Q_factors_" + self.configs[i])
rdc_lines = file.readlines()
file.close()
# Loop over the data.
for j in range(1, len(noe_lines)):
# Split the lines.
noe_viol = float(noe_lines[j].split()[1])
q_factor = float(rdc_lines[j].split()[1])
# Add the xy pair.
data[i].append([noe_viol, q_factor])
data_scaled[i].append([sqrt(noe_viol/self.noe_norm), q_factor])
# Write the data.
write_xy_header(file=grace_file, title='Correlation plot - %s RDC vs. NOE' % self.rdc_name, subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[9]*n], symbol_sizes=[[0.24]*n], linetype=[[0]*n], axis_labels=[['NOE violation (Angstrom\\S2\\N)', '%s RDC Q-factor (pales format)' % self.rdc_name]], legend_pos=[[1.1, 0.8]])
write_xy_header(file=grace_file_scaled, title='Correlation plot - %s RDC vs. NOE Q-factor' % self.rdc_name, subtitle=subtitle, sets=[n], set_names=[self.configs], set_colours=[colours], symbols=[[9]*n], symbol_sizes=[[0.24]*n], linetype=[[0]*n], axis_labels=[['Normalised NOE violation (Q = sqrt(U / \\xS\\f{}NOE\\si\\N\\S2\\N))', '%s RDC Q-factor (pales format)' % self.rdc_name]], legend_pos=[[1.1, 0.8]])
write_xy_data([data], file=grace_file, graph_type='xy')
write_xy_data([data_scaled], file=grace_file_scaled, graph_type='xy')
def noe_viol(self):
"""NOE violation calculations."""
# Redirect STDOUT to a log file.
if self.log:
sys.stdout = open(self.results_dir+sep+"logs" + sep + "NOE_viol.log", 'w')
# Create a directory for the save files.
dir = self.results_dir + sep + "NOE_results"
mkdir_nofail(dir=dir)
# Loop over the configurations.
for config in self.configs:
# Print out.
print("\n"*10 + "# Set up for config " + config + " #" + "\n")
# Open the results file.
out = open(self.results_dir+sep+"NOE_viol_" + config, 'w')
out_sorted = open(self.results_dir+sep+"NOE_viol_" + config + "_sorted", 'w')
out.write("%-20s%20s\n" % ("# Ensemble", "NOE_volation"))
out_sorted.write("%-20s%20s\n" % ("# Ensemble", "NOE_volation"))
# Create the data pipe.
self.interpreter.pipe.create("noe_viol_%s" % config, "N-state")
# Read the first structure.
self.interpreter.structure.read_pdb("ensembles" + sep + config + "0.pdb", dir=self.results_dir, set_mol_name=config, set_model_num=list(range(1, self.num_models+1)))
# Load all protons as the sequence.
self.interpreter.structure.load_spins("@H*", ave_pos=False)
# Create the pseudo-atoms.
for i in range(len(self.pseudo)):
self.interpreter.spin.create_pseudo(spin_name=self.pseudo[i][0], members=self.pseudo[i][1], averaging="linear")
self.interpreter.sequence.display()
# Read the NOE list.
self.interpreter.noe.read_restraints(file=self.noe_file)
# Set up the N-state model.
self.interpreter.n_state_model.select_model(model="fixed")
# Print out.
print("\n"*2 + "# Set up complete #" + "\n"*10)
# Loop over each ensemble.
noe_viol = []
for ens in range(self.num_ens):
# Print out the ensemble to both the log and screen.
if self.log:
sys.stdout.write(config + repr(ens) + "\n")
sys.stderr.write(config + repr(ens) + "\n")
# Delete the old structures and rename the molecule.
self.interpreter.structure.delete()
# Read the ensemble.
self.interpreter.structure.read_pdb("ensembles" + sep + config + repr(ens) + ".pdb", dir=self.results_dir, set_mol_name=config, set_model_num=list(range(1, self.num_models+1)))
# Get the atomic positions.
self.interpreter.structure.get_pos(ave_pos=False)
# Calculate the average NOE potential.
self.interpreter.calc()
# Sum the violations.
cdp.sum_viol = 0.0
for i in range(len(cdp.ave_dist)):
if cdp.quad_pot[i][2]:
cdp.sum_viol = cdp.sum_viol + cdp.quad_pot[i][2]
# Write out the NOE violation.
noe_viol.append([cdp.sum_viol, ens])
out.write("%-20i%30.15f\n" % (ens, cdp.sum_viol))
# Save the state.
self.interpreter.results.write(file="%s_results_%s" % (config, ens), dir=dir, force=True)
# Sort the NOE violations.
noe_viol.sort()
# Write the data.
for i in range(len(noe_viol)):
out_sorted.write("%-20i%20.15f\n" % (noe_viol[i][1], noe_viol[i][0]))
def rdc_analysis(self):
"""Perform the RDC part of the analysis."""
# Redirect STDOUT to a log file.
if self.log:
sys.stdout = open(self.results_dir+sep+"logs" + sep + "RDC_%s_analysis.log" % self.rdc_name, 'w')
# The dipolar constant.
d = 0.0
if self.bond_length != None:
d = 3.0 / (2.0*pi) * dipolar_constant(g13C, g1H, self.bond_length)
# Create a directory for the save files.
dir = self.results_dir + sep + "RDC_%s_results" % self.rdc_name
mkdir_nofail(dir=dir)
# Loop over the configurations.
for config in self.configs:
# Print out.
print("\n"*10 + "# Set up for config " + config + " #" + "\n")
# Open the results files.
out = open(self.results_dir+sep+"Q_factors_" + config, 'w')
out_sorted = open(self.results_dir+sep+"Q_factors_" + config + "_sorted", 'w')
out.write("%-20s%20s%20s\n" % ("# Ensemble", "RDC_Q_factor(pales)", "RDC_Q_factor(standard)"))
out_sorted.write("%-20s%20s\n" % ("# Ensemble", "RDC_Q_factor(pales)"))
# Create the data pipe.
self.interpreter.pipe.create("rdc_analysis_%s" % config, "N-state")
# Read the first structure.
self.interpreter.structure.read_pdb("ensembles_superimposed" + sep + config + "0.pdb", dir=self.results_dir, set_mol_name=config, set_model_num=list(range(1, self.num_models+1)))
# Load all spins as the sequence.
self.interpreter.structure.load_spins(ave_pos=False)
# Create the pseudo-atoms.
for i in range(len(self.pseudo)):
self.interpreter.spin.create_pseudo(spin_name=self.pseudo[i][0], members=self.pseudo[i][1], averaging="linear")
self.interpreter.sequence.display()
# Read the RDC data.
self.interpreter.rdc.read(align_id=self.rdc_file, file=self.rdc_file, spin_id1_col=self.rdc_spin_id1_col, spin_id2_col=self.rdc_spin_id2_col, data_col=self.rdc_data_col, error_col=self.rdc_error_col)
# Define the magnetic dipole-dipole relaxation interaction.
if self.bond_length != None:
self.interpreter.interatom.set_dist(spin_id1='@C*', spin_id2='@H*', ave_dist=self.bond_length)
self.interpreter.interatom.set_dist(spin_id1='@C*', spin_id2='@Q*', ave_dist=self.bond_length)
else:
self.interpreter.interatom.read_dist(file=self.bond_length_file, spin_id1_col=1, spin_id2_col=2, data_col=3)
# Set the nuclear isotope.
self.interpreter.spin.isotope(isotope='13C', spin_id='@C*')
self.interpreter.spin.isotope(isotope='1H', spin_id='@H*')
self.interpreter.spin.isotope(isotope='1H', spin_id='@Q*')
# Set up the model.
self.interpreter.n_state_model.select_model(model="fixed")
# Print out.
print("\n"*2 + "# Set up complete #" + "\n"*10)
# Loop over each ensemble.
q_factors = []
for ens in range(self.num_ens):
# Print out the ensemble to both the log and screen.
if self.log:
sys.stdout.write(config + repr(ens) + "\n")
sys.stderr.write(config + repr(ens) + "\n")
# Delete the old structures.
self.interpreter.structure.delete()
# Read the ensemble.
self.interpreter.structure.read_pdb("ensembles_superimposed" + sep + config + repr(ens) + ".pdb", dir=self.results_dir, set_mol_name=config, set_model_num=list(range(1, self.num_models+1)))
# Get the positional information, then load the CH vectors.
self.interpreter.structure.get_pos(ave_pos=False)
if self.bond_length != None:
self.interpreter.interatom.set_dist(spin_id1='@C*', spin_id2='@H*', ave_dist=self.bond_length)
else:
self.interpreter.interatom.read_dist(file=self.bond_length_file, spin_id1_col=1, spin_id2_col=2, data_col=3)
self.interpreter.interatom.unit_vectors(ave=False)
# Minimisation.
#grid_search(inc=4)
self.interpreter.minimise("simplex", constraints=False)
# Store and write out the Q-factors.
q_factors.append([cdp.q_rdc, ens])
out.write("%-20i%20.15f%20.15f\n" % (ens, cdp.q_rdc, cdp.q_rdc_norm2))
# Calculate the alignment tensor in Hz, and store it for reference.
cdp.align_tensor_Hz = d * cdp.align_tensors[0].A
cdp.align_tensor_Hz_5D = d * cdp.align_tensors[0].A_5D
# Save the state.
self.interpreter.results.write(file="%s_results_%s" % (config, ens), dir=dir, force=True)
# Sort the NOE violations.
q_factors.sort()
# Write the data.
for i in range(len(q_factors)):
out_sorted.write("%-20i%20.15f\n" % (q_factors[i][1], q_factors[i][0]))
def sample(self):
"""Generate the ensembles by random sampling of the snapshots."""
# Create the directory for the ensembles, if needed.
mkdir_nofail(dir=self.results_dir + sep + "ensembles")
# Loop over the configurations.
for conf_index in range(len(self.configs)):
# Loop over each ensemble.
for ens in range(self.num_ens):
# Random sampling.
rand = []
for j in range(self.num_models):
rand.append(randint(self.snapshot_min[conf_index], self.snapshot_max[conf_index]))
# Print out.
print("Generating ensemble %s%s from structures %s." % (self.configs[conf_index], ens, rand))
# The file name.
file_name = "ensembles" + sep + self.configs[conf_index] + repr(ens) + ".pdb"
# Open the output file.
out = open(self.results_dir+sep+file_name, 'w')
# Header.
out.write("REM Structures: " + repr(rand) + "\n")
# Concatenation the files.
for j in range(self.num_models):
# The random file.
rand_name = self.snapshot_dir[conf_index] + sep + self.configs[conf_index] + repr(rand[j]) + ".pdb"
# Append the file.
out.write(open(rand_name).read())
# Close the file.
out.close()
def superimpose(self):
"""Superimpose the ensembles using fit to first in Molmol."""
# Create the output directory.
mkdir_nofail("ensembles_superimposed")
# Logging turned on.
if self.log:
log = open(self.results_dir+sep+"logs" + sep + "superimpose_molmol.stderr", 'w')
sys.stdout = open(self.results_dir+sep+"logs" + sep + "superimpose.log", 'w')
# Loop over S and R.
for config in ["R", "S"]:
# Loop over each ensemble.
for ens in range(self.num_ens):
# The file names.
file_in = "ensembles" + sep + config + repr(ens) + ".pdb"
file_out = "ensembles_superimposed" + sep + config + repr(ens) + ".pdb"
# Print out.
sys.stderr.write("Superimposing %s with Molmol, output to %s.\n" % (file_in, file_out))
if self.log:
log.write("\n\n\nSuperimposing %s with Molmol, output to %s.\n" % (file_in, file_out))
# Failure handling (if a failure occurred and this is rerun, skip all existing files).
if access(self.results_dir+sep+file_out, F_OK):
continue
# Open the Molmol pipe.
pipe = Popen("molmol -t -f -", shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=False)
# Init all.
pipe.stdin.write("InitAll yes\n")
# Read the PDB.
pipe.stdin.write("ReadPdb " + self.results_dir+sep+file_in + "\n")
# Fitting to mean.
pipe.stdin.write("Fit to_first 'selected'\n")
pipe.stdin.write("Fit to_mean 'selected'\n")
# Write the result.
pipe.stdin.write("WritePdb " + self.results_dir+sep+file_out + "\n")
# End Molmol.
pipe.stdin.close()
# Get STDOUT and STDERR.
sys.stdout.write(pipe.stdout.read())
if self.log:
log.write(pipe.stderr.read())
# Close the pipe.
pipe.stdout.close()
pipe.stderr.close()
# Open the superimposed file in relax.
self.interpreter.reset()
self.interpreter.pipe.create('out', 'N-state')
self.interpreter.structure.read_pdb(file_out)
# Fix the retarded MOLMOL proton naming.
for model in cdp.structure.structural_data:
# Alias.
mol = model.mol[0]
# Loop over all atoms.
for i in range(len(mol.atom_name)):
# A proton.
if search('H', mol.atom_name[i]):
mol.atom_name[i] = mol.atom_name[i][1:] + mol.atom_name[i][0]
# Replace the superimposed file.
self.interpreter.structure.write_pdb(config + repr(ens) + ".pdb", dir=self.results_dir+sep+"ensembles_superimposed", force=True)
class NOE_calc:
def __init__(self, pipe_name=None, pipe_bundle=None, file_root='noe', results_dir=None, save_state=True):
"""Perform relaxation curve fitting.
To use this auto-analysis, a data pipe with all the required data needs to be set up. This data pipe should contain the following:
- All the spins loaded.
- Unresolved spins deselected.
- The NOE peak intensities from the saturated and reference spectra.
- Either the baseplane noise RMDS values should be set or replicated spectra loaded.
@keyword pipe_name: The name of the data pipe containing all of the data for the analysis.
@type pipe_name: str
@keyword pipe_bundle: The data pipe bundle to associate all spawned data pipes with.
@type pipe_bundle: str
@keyword file_root: File root of the output filea.
@type file_root: str
@keyword results_dir: The directory where results files are saved.
@type results_dir: str
@keyword save_state: A flag which if True will cause a relax save state to be created at the end of the analysis.
@type save_state: bool
"""
# Execution lock.
status.exec_lock.acquire(pipe_bundle, mode='auto-analysis')
# Set up the analysis status object.
status.init_auto_analysis(pipe_bundle, type='noe')
status.current_analysis = pipe_bundle
# Store the args.
self.save_state = save_state
self.pipe_name = pipe_name
self.pipe_bundle = pipe_bundle
self.file_root = file_root
self.results_dir = results_dir
if self.results_dir:
self.grace_dir = results_dir + sep + 'grace'
else:
self.grace_dir = 'grace'
# Data checks.
self.check_vars()
# Set the data pipe to the current data pipe.
if self.pipe_name != cdp_name():
switch(self.pipe_name)
# Load the interpreter.
self.interpreter = Interpreter(show_script=False, quit=False, raise_relax_error=True)
self.interpreter.populate_self()
self.interpreter.on(verbose=False)
# Execute.
self.run()
# Finish and unlock execution.
status.auto_analysis[self.pipe_bundle].fin = True
status.current_analysis = None
status.exec_lock.release()
def run(self):
"""Set up and run the NOE analysis."""
# Peak intensity error analysis.
self.interpreter.spectrum.error_analysis()
# Calculate the NOEs.
self.interpreter.calc()
# Save the NOEs.
self.interpreter.value.write(param='noe', file=self.file_root+'.out', dir=self.results_dir, force=True)
# Save the results.
self.interpreter.results.write(file='results', dir=self.results_dir, force=True)
# Create Grace plots of the data.
self.interpreter.grace.write(y_data_type='ref', file='ref.agr', dir=self.grace_dir, force=True)
self.interpreter.grace.write(y_data_type='sat', file='sat.agr', dir=self.grace_dir, force=True)
self.interpreter.grace.write(y_data_type='noe', file='noe.agr', dir=self.grace_dir, force=True)
# Save the program state.
if self.save_state:
self.interpreter.state.save(state=self.file_root+'.save', dir=self.results_dir, force=True)
def check_vars(self):
"""Check that the user has set the variables correctly."""
# The pipe name.
if not has_pipe(self.pipe_name):
raise RelaxNoPipeError(self.pipe_name)
class Relax_disp:
"""The relaxation dispersion auto-analysis."""
# Some class variables.
opt_func_tol = 1e-25
opt_max_iterations = int(1e7)
def __init__(self, pipe_name=None, pipe_bundle=None, results_dir=None, models=[MODEL_R2EFF], grid_inc=11, mc_sim_num=500, modsel='AIC', pre_run_dir=None, insignificance=0.0, numeric_only=False, mc_sim_all_models=False, eliminate=True):
"""Perform a full relaxation dispersion analysis for the given list of models.
@keyword pipe_name: The name of the data pipe containing all of the data for the analysis.
@type pipe_name: str
@keyword pipe_bundle: The data pipe bundle to associate all spawned data pipes with.
@type pipe_bundle: str
@keyword results_dir: The directory where results files are saved.
@type results_dir: str
@keyword models: The list of relaxation dispersion models to optimise.
@type models: list of str
@keyword grid_inc: Number of grid search increments.
@type grid_inc: int
@keyword mc_sim_num: The number of Monte Carlo simulations to be used for error analysis at the end of the analysis.
@type mc_sim_num: int
@keyword modsel: The model selection technique to use in the analysis to determine which model is the best for each spin cluster. This can currently be one of 'AIC', 'AICc', and 'BIC'.
@type modsel: str
@keyword pre_run_dir: The optional directory containing the dispersion auto-analysis results from a previous run. The optimised parameters from these previous results will be used as the starting point for optimisation rather than performing a grid search. This is essential for when large spin clusters are specified, as a grid search becomes prohibitively expensive with clusters of three or more spins. At some point a RelaxError will occur because the grid search is impossibly large. For the cluster specific parameters, i.e. the populations of the states and the exchange parameters, an average value will be used as the starting point. For all other parameters, the R20 values for each spin and magnetic field, as well as the parameters related to the chemical shift difference dw, the optimised values of the previous run will be directly copied.
@type pre_run_dir: None or str
@keyword insignificance: The R2eff/R1rho value in rad/s by which to judge insignificance. If the maximum difference between two points on all dispersion curves for a spin is less than this value, that spin will be deselected. This does not affect the 'No Rex' model. Set this value to 0.0 to use all data. The value will be passed on to the relax_disp.insignificance user function.
@type insignificance: float
@keyword numeric_only: The class of models to use in the model selection. The default of False allows all dispersion models to be used in the analysis (no exchange, the analytic models and the numeric models). The value of True will activate a pure numeric solution - the analytic models will be optimised, as they are very useful for replacing the grid search for the numeric models, but the final model selection will not include them.
@type numeric_only: bool
@keyword mc_sim_all_models: A flag which if True will cause Monte Carlo simulations to be performed for each individual model. Otherwise Monte Carlo simulations will be reserved for the final model.
@type mc_sim_all_models: bool
@keyword eliminate: A flag which if True will enable the elimination of failed models and failed Monte Carlo simulations through the eliminate user function.
@type eliminate: bool
"""
# Printout.
title(file=sys.stdout, text="Relaxation dispersion auto-analysis", prespace=4)
# Execution lock.
status.exec_lock.acquire(pipe_bundle, mode='auto-analysis')
# Set up the analysis status object.
status.init_auto_analysis(pipe_bundle, type='relax_disp')
status.current_analysis = pipe_bundle
# Store the args.
self.pipe_name = pipe_name
self.pipe_bundle = pipe_bundle
self.results_dir = results_dir
self.models = models
self.grid_inc = grid_inc
self.mc_sim_num = mc_sim_num
self.modsel = modsel
self.pre_run_dir = pre_run_dir
self.insignificance = insignificance
self.numeric_only = numeric_only
self.mc_sim_all_models = mc_sim_all_models
self.eliminate = eliminate
# No results directory, so default to the current directory.
if not self.results_dir:
self.results_dir = getcwd()
# Data checks.
self.check_vars()
# Load the interpreter.
self.interpreter = Interpreter(show_script=False, quit=False, raise_relax_error=True)
self.interpreter.populate_self()
self.interpreter.on(verbose=False)
# Execute.
self.run()
# Finish and unlock execution.
status.auto_analysis[self.pipe_bundle].fin = True
status.current_analysis = None
status.exec_lock.release()
def is_model_for_selection(self, model=None):
"""Determine if the model should be used for model selection.
@keyword model: The model to check.
@type model: str
@return: True if the model should be included in the model selection list, False if not.
@rtype: bool
"""
# Skip the 'R2eff' base model.
if model == 'R2eff':
return False
# Do not use the analytic models.
if self.numeric_only and model in MODEL_LIST_ANALYTIC:
return False
# All models allowed.
return True
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 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 nesting(self, model=None):
"""Support for model nesting.
If model nesting is detected, the optimised parameters from the simpler model will be used for the more complex model. The method will then signal if the nesting condition is met for the model, allowing the grid search to be skipped.
@keyword model: The model to be optimised.
@type model: str
@return: True if the model is the more complex model in a nested pair and the parameters of the simpler model have been copied. False otherwise.
@rtype: bool
"""
# Printout.
subsection(file=sys.stdout, text="Nesting and model equivalence checks", prespace=1)
# The simpler model.
nested_pipe = None
if model == MODEL_LM63_3SITE and MODEL_LM63 in self.models:
nested_pipe = MODEL_LM63
if model == MODEL_CR72_FULL and MODEL_CR72 in self.models:
nested_pipe = MODEL_CR72
if model == MODEL_MMQ_CR72 and MODEL_CR72 in self.models:
nested_pipe = MODEL_CR72
if model == MODEL_NS_CPMG_2SITE_3D_FULL and MODEL_NS_CPMG_2SITE_3D in self.models:
nested_pipe = MODEL_NS_CPMG_2SITE_3D
if model == MODEL_NS_CPMG_2SITE_STAR_FULL and MODEL_NS_CPMG_2SITE_STAR in self.models:
nested_pipe = MODEL_NS_CPMG_2SITE_STAR
if model == MODEL_NS_MMQ_3SITE_LINEAR and MODEL_NS_MMQ_2SITE in self.models:
nested_pipe = MODEL_NS_MMQ_2SITE
if model == MODEL_NS_MMQ_3SITE:
if MODEL_NS_MMQ_3SITE_LINEAR in self.models:
nested_pipe = MODEL_NS_MMQ_3SITE_LINEAR
elif MODEL_NS_MMQ_2SITE in self.models:
nested_pipe = MODEL_NS_MMQ_2SITE
if model == MODEL_NS_R1RHO_3SITE_LINEAR and MODEL_NS_R1RHO_2SITE in self.models:
nested_pipe = MODEL_NS_R1RHO_2SITE
if model == MODEL_NS_R1RHO_3SITE:
if MODEL_NS_R1RHO_3SITE_LINEAR in self.models:
nested_pipe = MODEL_NS_R1RHO_3SITE_LINEAR
elif MODEL_NS_R1RHO_2SITE in self.models:
nested_pipe = MODEL_NS_R1RHO_2SITE
# Using the analytic solution.
analytic = False
if model in [MODEL_NS_CPMG_2SITE_3D, MODEL_NS_CPMG_2SITE_EXPANDED, MODEL_NS_CPMG_2SITE_STAR] and MODEL_CR72 in self.models:
nested_pipe = MODEL_CR72
analytic = True
elif model == MODEL_NS_MMQ_2SITE and MODEL_MMQ_CR72 in self.models:
nested_pipe = MODEL_MMQ_CR72
analytic = True
if model == MODEL_NS_R1RHO_2SITE and MODEL_MP05 in self.models:
nested_pipe = MODEL_MP05
analytic = True
# No nesting.
if not nested_pipe:
print("No model nesting or model equivalence detected.")
return False
# Printout.
if analytic:
print("Model equivalence detected, copying the optimised parameters from the analytic '%s' model rather than performing a grid search." % nested_pipe)
else:
print("Model nesting detected, copying the optimised parameters from the '%s' model rather than performing a grid search." % nested_pipe)
# Loop over the spins to copy the parameters.
for spin, spin_id in spin_loop(return_id=True, skip_desel=True):
# Get the nested spin.
nested_spin = return_spin(spin_id=spin_id, pipe=nested_pipe)
# The R20 parameters.
if hasattr(nested_spin, 'r2'):
if model in [MODEL_CR72_FULL, MODEL_NS_CPMG_2SITE_3D_FULL, MODEL_NS_CPMG_2SITE_STAR_FULL]:
setattr(spin, 'r2a', deepcopy(nested_spin.r2))
setattr(spin, 'r2b', deepcopy(nested_spin.r2))
else:
setattr(spin, 'r2', deepcopy(nested_spin.r2))
# The LM63 3-site model parameters.
if model == MODEL_LM63_3SITE:
setattr(spin, 'phi_ex_B', deepcopy(nested_spin.phi_ex))
setattr(spin, 'phi_ex_C', deepcopy(nested_spin.phi_ex))
setattr(spin, 'kB', deepcopy(nested_spin.kex))
setattr(spin, 'kC', deepcopy(nested_spin.kex))
# All other spin parameters.
for param in spin.params:
if param in ['r2', 'r2a', 'r2b']:
continue
# The parameter does not exist.
if not hasattr(nested_spin, param):
continue
# Skip the LM63 3-site model parameters
if model == MODEL_LM63_3SITE and param in ['phi_ex', 'kex']:
continue
# Copy the parameter.
setattr(spin, param, deepcopy(getattr(nested_spin, param)))
# Nesting.
return True
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 pre_run_parameters(self, model=None):
"""Copy parameters from an earlier analysis.
@keyword model: The model to be optimised.
@type model: str
"""
# Printout.
subsection(file=sys.stdout, text="Pre-run parameters", prespace=1)
# Create a temporary data pipe for the previous run.
self.interpreter.pipe.create(pipe_name='pre', pipe_type='relax_disp')
# Load the previous results.
path = self.pre_run_dir + sep + model
self.interpreter.results.read(file='results', dir=path)
# Copy the parameters.
self.interpreter.relax_disp.parameter_copy(pipe_from='pre', pipe_to=model)
# Finally, switch back to the original data pipe and delete the temporary one.
self.interpreter.pipe.switch(pipe_name=model)
self.interpreter.pipe.delete(pipe_name='pre')
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 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)
