def peak_intensity_type(ri_id=None, type=None):
"""Set the type of intensity measured for the peaks.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword type: The peak intensity type, one of 'height' or 'volume'.
@type type: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['height', 'volume']
if type not in valid:
raise RelaxError(
"The '%s' peak intensity type is unknown. Please select one of %s."
% (type, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the type.
cdp.exp_info.setup_peak_intensity_type(ri_id, type)
def temp_calibration(ri_id=None, method=None):
"""Set the temperature calibration method.
@keyword ri_id: The relaxation data type, ie 'R1', 'R2', or 'NOE'.
@type ri_id: str
@keyword method: The temperature calibration method.
@type method: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = ['methanol', 'monoethylene glycol', 'no calibration applied']
if method not in valid:
warn(
RelaxWarning(
"The '%s' method is unknown. Please try to use one of %s." %
(method, valid)))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_calibration_setup(ri_id, method)
def software(name=None, version=None, url=None, vendor_name=None, cite_ids=None, tasks=None):
"""Select by name the software used in the analysis.
@param name: The name of the software program.
@type name: str
@keyword version: The program version.
@type version: None or str
@keyword url: The program's URL.
@type url: None or str
@keyword vendor_name: The name of the company or person behind the program.
@type vendor_name: str
@keyword cite_ids: The citation ID numbers.
@type cite_ids: None or str
@keyword tasks: The tasks performed by the program.
@type tasks: list of str
"""
# Test if the current pipe exists.
check_pipe()
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Place the data in the container.
cdp.exp_info.software_setup(name=name, version=version, url=url, vendor_name=vendor_name, cite_ids=cite_ids, tasks=tasks)
def thiol_state(state=None):
"""Set the thiol state of the system.
@keyword state: The thiol state of the molecule.
@type state: str
"""
# Test if the current pipe exists.
check_pipe()
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Place the data in the container.
cdp.exp_info.setup_thiol(state=state)
def citation(cite_id=None, authors=None, doi=None, pubmed_id=None, full_citation=None, title=None, status=None, type=None, journal_abbrev=None, journal_full=None, volume=None, issue=None, page_first=None, page_last=None, year=None):
"""Store a citation.
@keyword cite_id: The citation ID string.
@type cite_id: str
@keyword authors: The list of authors. Each author element is a list of four elements: the first name, last name, first initial, and middle initials.
@type authors: list of lists of str
@keyword doi: The DOI number, e.g. "10.1000/182".
@type doi: None or str
@keyword pubmed_id: The identification code assigned to the publication by PubMed.
@type pubmed_id: None or int
@keyword full_citation: A full citation in a format similar to that used in a journal article by either cutting and pasting from another document or by typing. Please include author names, title, journal, page numbers, and year or equivalent information for the type of publication given.
@type full_citation: str
@keyword title: The title of the publication.
@type title: str
@keyword status: The publication status. Can be one of in "preparation", "in press", "published", "retracted", or "submitted".
@type status: str
@keyword type: The publication type. Can be one of "abstract", "BMRB only", "book", "book chapter", "internet", "journal", "personal communication", or "thesis".
@type type: str
@keyword journal_abbrev: A standard journal abbreviation as defined by the Chemical Abstract Services for the journal where the data are or will be published. If the data in the deposition are related to a J. Biomol. NMR paper, the value must be 'J. Biomol. NMR' to alert the BMRB annotators so that the deposition is properly processed. If the depositor truly does not know the journal, a value of 'not known' or 'na' is acceptable.
@type journal_abbrev: str
@keyword journal_full: The full journal name.
@type journal_full: str
@keyword volume: The volume number.
@type volume: int
@keyword issue: The issue number.
@type issue: int
@keyword page_first: The first page number.
@type page_first: int
@keyword page_last: The last page number.
@type page_last: int
@keyword year: The publication year.
@type year: int
"""
# Test if the current pipe exists.
check_pipe()
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Place the data in the container.
cdp.exp_info.add_citation(cite_id=cite_id, authors=authors, doi=doi, pubmed_id=pubmed_id, full_citation=full_citation, title=title, status=status, type=type, journal_abbrev=journal_abbrev, journal_full=journal_full, volume=volume, issue=issue, page_first=page_first, page_last=page_last, year=year)
def temp_control(ri_id=None, method=None):
"""Set the temperature control method.
@keyword ri_id: The relaxation data ID string.
@type ri_id: str
@keyword method: The temperature control method.
@type method: str
"""
# Test if the current pipe exists.
check_pipe()
# Test if sequence data is loaded.
if not exists_mol_res_spin_data():
raise RelaxNoSequenceError
# Test if data exists.
if not hasattr(cdp, 'ri_ids') or ri_id not in cdp.ri_ids:
raise RelaxNoRiError(ri_id)
# Check the values, and warn if not in the list.
valid = [
'single scan interleaving', 'temperature compensation block',
'single scan interleaving and temperature compensation block',
'single fid interleaving', 'single experiment interleaving',
'no temperature control applied'
]
if method not in valid:
raise RelaxError(
"The '%s' method is unknown. Please select one of %s." %
(method, valid))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Store the method.
cdp.exp_info.temp_control_setup(ri_id, method)
class PipeContainer(Prototype):
"""Class containing all the program data."""
def __init__(self):
"""Set up all the PipeContainer data structures."""
# The molecule-residue-spin object.
self.mol = MoleculeList()
# The interatomic data object.
self.interatomic = InteratomList()
# The data pipe type.
self.pipe_type = None
# Hybrid models.
self.hybrid_pipes = []
def __repr__(self):
"""The string representation of the object.
Rather than using the standard Python conventions (either the string representation of the
value or the "<...desc...>" notation), a rich-formatted description of the object is given.
"""
# Intro text.
text = "The data pipe storage object.\n"
# Special objects/methods (to avoid the getattr() function call on).
spec_obj = ['exp_info', 'mol', 'interatomic', 'diff_tensor', 'structure']
# Objects.
text = text + "\n"
text = text + "Objects:\n"
for name in dir(self):
# Molecular list.
if name == 'mol':
text = text + " mol: The molecule list (for the storage of the spin system specific data)\n"
# Interatomic data list.
if name == 'interatomic':
text = text + " interatomic: The interatomic data list (for the storage of the inter-spin system data)\n"
# Diffusion tensor.
if name == 'diff_tensor':
text = text + " diff_tensor: The Brownian rotational diffusion tensor data object\n"
# Molecular structure.
if name == 'structure':
text = text + " structure: The 3D molecular data object\n"
# The experimental info data container.
if name == 'exp_info':
text = text + " exp_info: The data container for experimental information\n"
# Skip the PipeContainer methods.
if name in list(self.__class__.__dict__.keys()):
continue
# Skip certain objects.
if match("^_", name) or name in spec_obj:
continue
# Add the object's attribute to the text string.
text = text + " " + name + ": " + repr(getattr(self, name)) + "\n"
# Return the text representation.
return text
def _back_compat_hook(self, file_version=None):
"""Method for converting old data structures to the new ones.
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
"""
# Relaxation data.
self._back_compat_hook_ri_data()
def _back_compat_hook_ri_data(self):
"""Converting the old relaxation data structures to the new ones."""
# Nothing to do.
if not (hasattr(cdp, 'frq_labels') and hasattr(cdp, 'noe_r1_table') and hasattr(cdp, 'remap_table')):
return
# Initialise the new structures.
cdp.ri_ids = []
cdp.ri_type = {}
frq = {} # This will be placed into cdp later as cdp.spectrometer_frq still exists.
# Generate the new structures.
for i in range(cdp.num_ri):
# The ID.
ri_id = "%s_%s" % (cdp.ri_labels[i], cdp.frq_labels[cdp.remap_table[i]])
# Not unique.
if ri_id in cdp.ri_ids:
# Loop until a unique ID is found.
for j in range(100):
# New id.
new_id = "%s_%s" % (ri_id, j)
# Unique.
if not new_id in cdp.ri_ids:
ri_id = new_id
break
# Add the ID.
cdp.ri_ids.append(ri_id)
# The relaxation data type.
cdp.ri_type[ri_id] = cdp.ri_labels[i]
# The frequency data.
frq[ri_id] = cdp.frq[cdp.remap_table[i]]
# Delete the old structures.
del cdp.frq
del cdp.frq_labels
del cdp.noe_r1_table
del cdp.num_frq
del cdp.num_ri
del cdp.remap_table
del cdp.ri_labels
# Set the frequencies.
cdp.frq = frq
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes', node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0], file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0], file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0], file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0], dir=dir, file_version=file_version)
def is_empty(self):
"""Method for testing if the data pipe is empty.
@return: True if the data pipe is empty, False otherwise.
@rtype: bool
"""
# Is the molecule structure data object empty?
if hasattr(self, 'structure'):
return False
# Is the molecule/residue/spin data object empty?
if not self.mol.is_empty():
return False
# Is the interatomic data object empty?
if not self.interatomic.is_empty():
return False
# Tests for the initialised data (the pipe type can be set in an empty data pipe, so this isn't checked).
if self.hybrid_pipes:
return False
# An object has been added to the container.
for name in dir(self):
# Skip the objects initialised in __init__().
if name in ['mol', 'interatomic', 'pipe_type', 'hybrid_pipes']:
continue
# Skip the PipeContainer methods.
if name in list(self.__class__.__dict__.keys()):
continue
# Skip special objects.
if match("^_", name):
continue
# An object has been added.
return False
# The data pipe is empty.
return True
def to_xml(self, doc, element):
"""Create a XML element for the current data pipe.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The XML element to add the pipe XML element to.
@type element: XML element object
"""
# Add all simple python objects within the PipeContainer to the global element.
global_element = doc.createElement('global')
element.appendChild(global_element)
global_element.setAttribute('desc', 'Global data located in the top level of the data pipe')
fill_object_contents(doc, global_element, object=self, blacklist=['align_tensors', 'diff_tensor', 'exp_info', 'interatomic', 'hybrid_pipes', 'mol', 'pipe_type', 'structure'] + list(self.__class__.__dict__.keys()))
# Hybrid info.
self.xml_create_hybrid_element(doc, element)
# Add the experimental information.
if hasattr(self, 'exp_info'):
self.exp_info.to_xml(doc, element)
# Add the diffusion tensor data.
if hasattr(self, 'diff_tensor'):
self.diff_tensor.to_xml(doc, element)
# Add the alignment tensor data.
if hasattr(self, 'align_tensors'):
self.align_tensors.to_xml(doc, element)
# Add the molecule-residue-spin data.
self.mol.to_xml(doc, element)
# Add the interatomic data.
self.interatomic.to_xml(doc, element)
# Add the structural data, if it exists.
if hasattr(self, 'structure'):
self.structure.to_xml(doc, element)
def xml_create_hybrid_element(self, doc, element):
"""Create an XML element for the data pipe hybridisation information.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The element to add the hybridisation info to.
@type element: XML element object
"""
# Create the hybrid element and add it to the higher level element.
hybrid_element = doc.createElement('hybrid')
element.appendChild(hybrid_element)
# Set the hybridisation attributes.
hybrid_element.setAttribute('desc', 'Data pipe hybridisation information')
# Create an element to store the pipes list.
list_element = doc.createElement('pipes')
hybrid_element.appendChild(list_element)
# Add the pipes list.
text_val = doc.createTextNode(str(self.hybrid_pipes))
list_element.appendChild(text_val)
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes', node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0], file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0], file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0], file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0], dir=dir, file_version=file_version)
class PipeContainer(Prototype):
"""Class containing all the program data."""
def __init__(self):
"""Set up all the PipeContainer data structures."""
# The molecule-residue-spin object.
self.mol = MoleculeList()
# The interatomic data object.
self.interatomic = InteratomList()
# The data pipe type.
self.pipe_type = None
# Hybrid models.
self.hybrid_pipes = []
def __repr__(self):
"""The string representation of the object.
Rather than using the standard Python conventions (either the string representation of the
value or the "<...desc...>" notation), a rich-formatted description of the object is given.
"""
# Intro text.
text = "The data pipe storage object.\n"
# Special objects/methods (to avoid the getattr() function call on).
spec_obj = [
'exp_info', 'mol', 'interatomic', 'diff_tensor', 'structure'
]
# Objects.
text = text + "\n"
text = text + "Objects:\n"
for name in dir(self):
# Molecular list.
if name == 'mol':
text = text + " mol: The molecule list (for the storage of the spin system specific data)\n"
# Interatomic data list.
if name == 'interatomic':
text = text + " interatomic: The interatomic data list (for the storage of the inter-spin system data)\n"
# Diffusion tensor.
if name == 'diff_tensor':
text = text + " diff_tensor: The Brownian rotational diffusion tensor data object\n"
# Molecular structure.
if name == 'structure':
text = text + " structure: The 3D molecular data object\n"
# The experimental info data container.
if name == 'exp_info':
text = text + " exp_info: The data container for experimental information\n"
# Skip the PipeContainer methods.
if name in self.__class__.__dict__:
continue
# Skip certain objects.
if match("^_", name) or name in spec_obj:
continue
# Add the object's attribute to the text string.
text = text + " " + name + ": " + repr(getattr(self, name)) + "\n"
# Return the text representation.
return text
def _back_compat_hook(self, file_version=None):
"""Method for converting old data structures to the new ones.
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
"""
# Relaxation data.
self._back_compat_hook_ri_data()
def _back_compat_hook_ri_data(self):
"""Converting the old relaxation data structures to the new ones."""
# Nothing to do.
if not (hasattr(cdp, 'frq_labels') and hasattr(cdp, 'noe_r1_table')
and hasattr(cdp, 'remap_table')):
return
# Initialise the new structures.
cdp.ri_ids = []
cdp.ri_type = {}
frq = {
} # This will be placed into cdp later as cdp.spectrometer_frq still exists.
# Generate the new structures.
for i in range(cdp.num_ri):
# The ID.
ri_id = "%s_%s" % (cdp.ri_labels[i],
cdp.frq_labels[cdp.remap_table[i]])
# Not unique.
if ri_id in cdp.ri_ids:
# Loop until a unique ID is found.
for j in range(100):
# New id.
new_id = "%s_%s" % (ri_id, j)
# Unique.
if not new_id in cdp.ri_ids:
ri_id = new_id
break
# Add the ID.
cdp.ri_ids.append(ri_id)
# The relaxation data type.
cdp.ri_type[ri_id] = cdp.ri_labels[i]
# The frequency data.
frq[ri_id] = cdp.frq[cdp.remap_table[i]]
# Delete the old structures.
del cdp.frq
del cdp.frq_labels
del cdp.noe_r1_table
del cdp.num_frq
del cdp.num_ri
del cdp.remap_table
del cdp.ri_labels
# Set the frequencies.
cdp.frq = frq
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes',
node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0],
file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0],
file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0],
file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0],
dir=dir,
file_version=file_version)
def is_empty(self):
"""Method for testing if the data pipe is empty.
@return: True if the data pipe is empty, False otherwise.
@rtype: bool
"""
# Is the molecule structure data object empty?
if hasattr(self, 'structure'):
return False
# Is the molecule/residue/spin data object empty?
if not self.mol.is_empty():
return False
# Is the interatomic data object empty?
if not self.interatomic.is_empty():
return False
# Tests for the initialised data (the pipe type can be set in an empty data pipe, so this isn't checked).
if self.hybrid_pipes:
return False
# An object has been added to the container.
for name in dir(self):
# Skip the objects initialised in __init__().
if name in ['mol', 'interatomic', 'pipe_type', 'hybrid_pipes']:
continue
# Skip the PipeContainer methods.
if name in self.__class__.__dict__:
continue
# Skip special objects.
if match("^_", name):
continue
# An object has been added.
return False
# The data pipe is empty.
return True
def to_xml(self, doc, element, pipe_type=None):
"""Create a XML element for the current data pipe.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The XML element to add the pipe XML element to.
@type element: XML element object
@keyword pipe_type: The type of the pipe being converted to XML.
@type pipe_type: str
"""
# Add all simple python objects within the PipeContainer to the global element.
global_element = doc.createElement('global')
element.appendChild(global_element)
global_element.setAttribute(
'desc', 'Global data located in the top level of the data pipe')
fill_object_contents(
doc,
global_element,
object=self,
blacklist=[
'align_tensors', 'diff_tensor', 'exp_info', 'interatomic',
'hybrid_pipes', 'mol', 'pipe_type', 'structure'
] + list(self.__class__.__dict__.keys()))
# Hybrid info.
self.xml_create_hybrid_element(doc, element)
# Add the experimental information.
if hasattr(self, 'exp_info'):
self.exp_info.to_xml(doc, element)
# Add the diffusion tensor data.
if hasattr(self, 'diff_tensor'):
self.diff_tensor.to_xml(doc, element)
# Add the alignment tensor data.
if hasattr(self, 'align_tensors'):
self.align_tensors.to_xml(doc, element)
# Add the molecule-residue-spin data.
self.mol.to_xml(doc, element, pipe_type=pipe_type)
# Add the interatomic data.
self.interatomic.to_xml(doc, element, pipe_type=pipe_type)
# Add the structural data, if it exists.
if hasattr(self, 'structure'):
self.structure.to_xml(doc, element)
def xml_create_hybrid_element(self, doc, element):
"""Create an XML element for the data pipe hybridisation information.
@param doc: The XML document object.
@type doc: xml.dom.minidom.Document instance
@param element: The element to add the hybridisation info to.
@type element: XML element object
"""
# Create the hybrid element and add it to the higher level element.
hybrid_element = doc.createElement('hybrid')
element.appendChild(hybrid_element)
# Set the hybridisation attributes.
hybrid_element.setAttribute('desc',
'Data pipe hybridisation information')
# Create an element to store the pipes list.
list_element = doc.createElement('pipes')
hybrid_element.appendChild(list_element)
# Add the pipes list.
text_val = doc.createTextNode(str(self.hybrid_pipes))
list_element.appendChild(text_val)
def from_xml(self, pipe_node, file_version=None, dir=None):
"""Read a pipe container XML element and place the contents into this pipe.
@param pipe_node: The data pipe XML node.
@type pipe_node: xml.dom.minidom.Element instance
@keyword file_version: The relax XML version of the XML file.
@type file_version: int
@keyword dir: The name of the directory containing the results file (needed for loading external files).
@type dir: str
"""
# Test if empty.
if not self.is_empty():
raise RelaxFromXMLNotEmptyError(self.__class__.__name__)
# Get the global data node, and fill the contents of the pipe.
global_node = pipe_node.getElementsByTagName('global')[0]
xml_to_object(global_node, self, file_version=file_version)
# Backwards compatibility transformations.
self._back_compat_hook(file_version)
# Get the hybrid node (and its sub-node), and recreate the hybrid object.
hybrid_node = pipe_node.getElementsByTagName('hybrid')[0]
pipes_node = hybrid_node.getElementsByTagName('pipes')[0]
setattr(self, 'hybrid_pipes',
node_value_to_python(pipes_node.childNodes[0]))
# Get the experimental information data nodes and, if they exist, fill the contents.
exp_info_nodes = pipe_node.getElementsByTagName('exp_info')
if exp_info_nodes:
# Create the data container.
self.exp_info = ExpInfo()
# Fill its contents.
self.exp_info.from_xml(exp_info_nodes[0],
file_version=file_version)
# Get the diffusion tensor data nodes and, if they exist, fill the contents.
diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor')
if diff_tensor_nodes:
# Create the diffusion tensor object.
self.diff_tensor = DiffTensorData()
# Fill its contents.
self.diff_tensor.from_xml(diff_tensor_nodes[0],
file_version=file_version)
# Get the alignment tensor data nodes and, if they exist, fill the contents.
align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors')
if align_tensor_nodes:
# Create the alignment tensor object.
self.align_tensors = AlignTensorList()
# Fill its contents.
self.align_tensors.from_xml(align_tensor_nodes[0],
file_version=file_version)
# Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!).
interatom_nodes = pipe_node.getElementsByTagName('interatomic')
self.interatomic.from_xml(interatom_nodes, file_version=file_version)
# Recreate the molecule, residue, and spin data structure.
mol_nodes = pipe_node.getElementsByTagName('mol')
self.mol.from_xml(mol_nodes, file_version=file_version)
# Get the structural object nodes and, if they exist, fill the contents.
str_nodes = pipe_node.getElementsByTagName('structure')
if str_nodes:
# Create the structural object.
fail = False
self.structure = Internal()
# Fill its contents.
if not fail:
self.structure.from_xml(str_nodes[0],
dir=dir,
file_version=file_version)
def software_select(name, version=None):
"""Select by name the software used in the analysis.
@param name: The name of the software program.
@type name: str
@keyword version: The program version.
@type version: None or str
"""
# Test if the current pipe exists.
check_pipe()
# Unknown program.
if name not in ['relax', 'NMRPipe', 'Sparky', 'Bruker DC']:
raise RelaxError("The software '%s' is unknown. Please use the user function for manually specifying software details instead." % name)
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Init.
cite_ids = []
keys = []
software_keys = []
versions = []
# relax.
if name == 'relax':
# The info.
cite_ids.append(['relax_ref1', 'relax_ref2'])
keys.append(['dAuvergneGooley08a', 'dAuvergneGooley08b'])
software_keys.append('relax')
versions.append(version_full())
# NMRPipe.
elif name == 'NMRPipe':
# The info.
cite_ids.append(['nmrpipe_ref'])
keys.append(['Delaglio95'])
software_keys.append('NMRPipe')
versions.append(version)
# Sparky.
elif name == 'Sparky':
# Check if the version information has been supplied.
if not version:
raise RelaxError("The Sparky version number has not been supplied.")
# The info.
cite_ids.append(['sparky_ref'])
keys.append(['GoddardKneller'])
software_keys.append('Sparky')
versions.append(version)
# Bruker Dynamics Center.
elif name == 'Bruker DC':
# The info.
software_keys.append('DC')
versions.append(version)
# Get the info box.
info = Info_box()
# Loop over the citations.
for i in range(len(cite_ids)):
for j in range(len(cite_ids[i])):
# Alias the bib entry.
bib = info.bib[keys[i][j]]
# Add the citations.
cdp.exp_info.add_citation(cite_id=cite_ids[i][j], authors=bib.author2, doi=bib.doi, pubmed_id=bib.pubmed_id, full_citation=bib.cite_short(doi=False, url=False), title=bib.title, status=bib.status, type=bib.type, journal_abbrev=bib.journal, journal_full=bib.journal_full, volume=bib.volume, issue=bib.number, page_first=bib.page_first, page_last=bib.page_last, year=bib.year)
# Add the software info.
cdp.exp_info.software_setup(name=SOFTWARE[software_keys[i]].name, version=versions[i], vendor_name=SOFTWARE[software_keys[i]].authors, url=SOFTWARE[software_keys[i]].url, cite_ids=cite_ids, tasks=SOFTWARE[software_keys[i]].tasks)
def script(file=None, dir=None, analysis_type=None, model_selection=None, engine=None, model_elim=False, universal_solution=False):
"""Specify the scripts used in the analysis.
@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: None or str
@keyword analysis_type: The type of analysis performed.
@type analysis_type: str
@keyword model_selection: The model selection technique used, if relevant.
@type model_selection: None or str
@keyword engine: The software engine used in the analysis.
@type engine: str
@keyword model_elim: A model-free specific flag specifying if model elimination was performed.
@type model_elim: bool
@keyword universal_solution: A model-free specific flag specifying if the universal solution was sought after.
@type universal_solution: bool
"""
# Test if the current pipe exists.
check_pipe()
# Check.
allowed = ['frame order',
'jw',
'mf',
'N-state',
'noe',
'relax_fit'
]
if analysis_type not in allowed:
raise RelaxError("The analysis type '%s' should be one of %s." % (analysis_type, allowed))
# Set up the experimental info data container, if needed.
if not hasattr(cdp, 'exp_info'):
cdp.exp_info = ExpInfo()
# Extract the text.
f = open_read_file(file, dir)
text = f.read()
f.close()
# Init the citation structures.
cite_id = []
cite_key = []
# Model selection.
if model_selection in ['AIC', 'AICc', 'BIC', 'Bootstrap', 'CV', 'Expect', 'Overall']:
cite_id.append('model-free model selection')
cite_key.append('dAuvergneGooley03')
# Model-free model elimination.
if model_elim:
cite_id.append('model-free model elimination')
cite_key.append('dAuvergneGooley06')
# Universal solution citation.
if universal_solution:
cite_id.append('model-free set theory')
cite_key.append('dAuvergneGooley07')
# Get the info box.
info = Info_box()
# Loop over all citations.
for id, key in zip(cite_id, cite_key):
# Alias the bib entry.
bib = info.bib[key]
# Add the citation.
cdp.exp_info.add_citation(cite_id=id, authors=bib.author2, doi=bib.doi, pubmed_id=bib.pubmed_id, full_citation=bib.cite_short(doi=False, url=False), title=bib.title, status=bib.status, type=bib.type, journal_abbrev=bib.journal, journal_full=bib.journal_full, volume=bib.volume, page_first=bib.page_first, page_last=bib.page_last, year=bib.year)
# Place the data in the container.
cdp.exp_info.setup_script(file=file, dir=dir, text=text, cite_ids=cite_id, analysis_type=analysis_type, model_selection=model_selection, engine=engine, model_elim=model_elim, universal_solution=universal_solution)