def start(mode=None, profile_flag=False):
"""Execute relax.
@keyword mode: Force a relax mode, overriding the command line.
@type mode: str
@keyword profile_flag: Change this flag to True for code profiling.
@type profile_flag: bool
"""
# Normal relax operation.
relax = Relax()
# Override normal operation.
if mode:
# Override the mode.
relax.mode = mode
# Some defaults.
relax.script_file = None
relax.log_file = None
relax.tee_file = None
relax.multiprocessor_type = 'uni'
relax.n_processors = 1
# Process the command line arguments.
else:
relax.arguments()
# Store some start up info in the status object.
status.relax_mode = relax.mode
# Set up the multi-processor elements.
callbacks = Application_callback(master=relax)
verbosity = 0
if status.debug:
verbosity = 1
processor = load_multiprocessor(relax.multiprocessor_type, callbacks, processor_size=relax.n_processors, verbosity=verbosity)
# Place the processor fabric intro string into the info box.
info = Info_box()
info.multi_processor_string = processor.get_intro_string()
# Normal relax operation.
if not profile_flag:
# Execute relax in multi-processor mode (this includes the uni-processor for normal operation).
processor.run()
# relax in profiling mode.
else:
def print_stats(stats, status=0):
pstats.Stats(stats).sort_stats('time', 'name').print_stats()
# No profile module.
if not dep_check.profile_module:
sys.stderr.write("The profile module is not available, please install the Python development packages for profiling.\n\n")
sys.exit()
# Run relax in profiling mode.
profile.Profile.print_stats = print_stats
profile.runctx('processor.run()', globals(), locals())
def __init__(self, show_script=True, quit=True, raise_relax_error=False):
"""The interpreter class.
@param show_script: If true, the relax will print the script contents prior to
executing the script.
@type show_script: bool
@param quit: If true, the default, then relax will exit after running the
run() method.
@type quit: bool
@param raise_relax_error: If false, the default, then relax will print a nice error
message to STDERR, without a traceback, when a RelaxError
occurs. This is to make things nicer for the user.
@type raise_relax_error: bool
"""
# Place the arguments in the class namespace.
self.__show_script = show_script
self.__quit_flag = quit
self.__raise_relax_error = raise_relax_error
# Build the intro string.
info = Info_box()
self.__intro_string = info.intro_text()
# The prompts (change the Python prompt, as well as the function printouts).
if ansi.enable_control_chars(stream=1):
self.prompt_colour_on()
else:
self.prompt_colour_off()
# Set up the interpreter objects.
self._locals = self._setup()
def __init__(self,
locals=None,
rawin=None,
stdin=sys.stdin,
stdout=sys.stdout,
stderr=sys.stderr,
showInterpIntro=True):
"""Redefine the interpreter."""
# Execute the base class __init__() method.
wx.py.interpreter.Interpreter.__init__(self,
locals=locals,
rawin=rawin,
stdin=stdin,
stdout=stdout,
stderr=stderr,
showInterpIntro=showInterpIntro)
# The introductory text.
info = Info_box()
self.introText = info.intro_text()
# The relax interpreter.
interp = interpreter.Interpreter(show_script=False,
raise_relax_error=True)
# The locals.
self.locals = interp._locals
def __init__(self, show_script=True, raise_relax_error=False):
"""The interpreter class.
@param show_script: If true, the relax will print the script contents prior to
executing the script.
@type show_script: bool
@param raise_relax_error: If false, the default, then relax will print a nice error
message to STDERR, without a traceback, when a RelaxError
occurs. This is to make things nicer for the user.
@type raise_relax_error: bool
"""
# Place the arguments in the class namespace.
self.__show_script = show_script
self.__raise_relax_error = raise_relax_error
# Build the intro string.
info = Info_box()
self.__intro_string = info.intro_text()
# The prompts (change the Python prompt, as well as the function printouts).
if ansi.enable_control_chars(stream=1) and not status.show_gui:
self.prompt_colour_on()
else:
self.prompt_colour_off()
# Set up the interpreter objects.
self._locals = self._setup()
def __init__(self, locals=None, rawin=None, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr, showInterpIntro=True):
"""Redefine the interpreter."""
# Execute the base class __init__() method.
wx.py.interpreter.Interpreter.__init__(self, locals=locals, rawin=rawin, stdin=stdin, stdout=stdout, stderr=stderr, showInterpIntro=showInterpIntro)
# The introductory text.
info = Info_box()
self.introText = info.intro_text()
# The relax interpreter.
interp = interpreter.Interpreter(show_script=False, quit=False, raise_relax_error=True)
# The locals.
self.locals = interp._locals
def copyright_file(target, source, env):
"""Builder action for creating the LaTeX copyright notice file."""
# Print out.
print('')
print("##################################################")
print("# Creating the LaTeX relax copyright notice file #")
print("##################################################")
# The LaTeX file.
file = open(env['LATEX_DIR'] + sep + 'copyright.tex', 'w')
# Initialise the info box.
info = Info_box()
# The notice.
file.write("\\noindent %s\n\n" % info.copyright_latex)
file.write("\\vspace{5px}\n\n")
# The text.
file.write("\\noindent Permission is granted to copy, distribute and/or modify this document under the terms of the GNU General Public License (GPL), Version 3 or any later version published by the Free Software Foundation.\n")
file.write("\\vspace{5px}\n\n")
file.write("\\noindent The Oxygen Icons used herein are licensed under the terms of the GNU Lesser General Public License (GPL), Version 3 or any later version published by the Free Software Foundation.\n")
# Close the file.
file.close()
# Final printout.
print("\n\n\n")
def __init__(self, parent=None, id=-1, title="About relax"):
"""Build the dialog."""
# Initialise the program information container.
self.info = Info_box()
# Execute the base class __init__() method.
super(About_relax, self).__init__(parent=parent, id=id, title=title)
def front_page(self):
"""The main reference page."""
# Initialise the program information container.
info = Info_box()
# The HTML header.
text = HTML_HEADER
# The reference header.
text = text + "<center>"
text = text + "<img src=%s%s></img>" % (
IMAGE_PATH, 'ulysses_shadowless_400x168.png')
text = text + "<h1>relax references</h1>"
text = text + "</center>"
# Main refs.
text = text + "<h2>The program relax</h2>"
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley08a'].cite_html()
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley08b'].cite_html()
# GUI refs.
text = text + "<h3><i>The relax GUI</i></h3>"
text = text + "<p>%s</p>" % info.bib['Bieri11'].cite_html()
# Model-free refs.
text = text + "<h2>Model-free analysis</h2>"
text = text + "<p>For a model-free analysis, all of the following should be cited!</p>"
text = text + "<h3><i>Original Lipari-Szabo theory</i></h3>"
text = text + "<p>%s</p>" % info.bib['LipariSzabo82a'].cite_html()
text = text + "<p>%s</p>" % info.bib['LipariSzabo82b'].cite_html()
text = text + "<h3><i>Extended model-free theory</i></h3>"
text = text + "<p>%s</p>" % info.bib['Clore90'].cite_html()
text = text + "<h3><i>Model-free model selection</i></h3>"
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley03'].cite_html()
text = text + "<h3><i>Model-free model elimination</i></h3>"
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley06'].cite_html()
text = text + "<h3><i>Model-free minimisation</i></h3>"
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley08a'].cite_html()
text = text + "<h3><i>The new model-free analysis protocol</i></h3>"
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley07'].cite_html()
text = text + "<p>%s</p>" % info.bib['dAuvergneGooley08b'].cite_html()
text = text + "<h3><i>Comprehensive reference</i></h3>"
text = text + "<p>This PhD thesis expands on all of the d'Auvergne and Gooley references and describes model-free analysis and the program relax in more detail:</p>"
text = text + "<p>%s</p>" % info.bib['dAuvergne06'].cite_html()
# The footer.
text = text + HTML_FOOTER
self.html.SetPage(text)
def write(file=None, dir=None, version='3.1', force=False):
"""Create a BMRB NMR-STAR formatted file.
@keyword file: The name of the file to create or a file object.
@type file: str or file object
@keyword dir: The optional directory to place the file into. If set to 'pipe_name', then it will be placed in a directory with the same name as the current data pipe.
@type dir: str or None
@keyword version: The NMR-STAR version to create. This can be either '2.1', '3.0', or '3.1'.
@type version: str
@keyword force: A flag which if True will allow a currently existing file to be overwritten.
@type force: bool
"""
# Test if bmrblib is installed.
if not dep_check.bmrblib_module:
raise RelaxNoModuleInstallError('BMRB library', 'bmrblib')
# Test if the current data pipe exists.
pipe_name = cdp_name()
if not pipe_name:
raise RelaxNoPipeError
# Check the file name.
if file == None:
raise RelaxError("The file name must be specified.")
# A file object.
if isinstance(file, str):
# The special data pipe name directory.
if dir == 'pipe_name':
dir = pipe_name
# Get the full file path.
file = get_file_path(file, dir)
# Fail if the file already exists and the force flag is False.
if access(file, F_OK) and not force:
raise RelaxFileOverwriteError(file, 'force flag')
# Print out.
print("Opening the file '%s' for writing." % file)
# Create the directories.
mkdir_nofail(dir, verbosity=0)
# Get the info box.
info = Info_box()
# Add the relax citations.
for id, key in zip(['relax_ref1', 'relax_ref2'],
['dAuvergneGooley08a', 'dAuvergneGooley08b']):
# Alias the bib entry.
bib = info.bib[key]
# Add.
exp_info.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,
issue=bib.number,
page_first=bib.page_first,
page_last=bib.page_last,
year=bib.year)
# Add the relax software package.
exp_info.software(name=exp_info.SOFTWARE['relax'].name,
version=version_full(),
vendor_name=exp_info.SOFTWARE['relax'].authors,
url=exp_info.SOFTWARE['relax'].url,
cite_ids=['relax_ref1', 'relax_ref2'],
tasks=exp_info.SOFTWARE['relax'].tasks)
# Execute the specific BMRB writing code.
api = return_api(pipe_name=pipe_name)
api.bmrb_write(file, version=version)
# Add the file to the results file list.
if isinstance(file, str):
add_result_file(type='text', label='BMRB', file=file)
def run(self):
"""Execute relax.
This is the application callback method executed by the multi-processor framework.
"""
# Set up the warning system.
lib.warnings.setup()
# Logging.
if self.log_file:
io_streams_log(self.log_file)
# Tee.
elif self.tee_file:
io_streams_tee(self.tee_file)
# Show the version number and exit.
if self.mode == 'version':
print('relax ' + version.version_full())
return
# Show the relax info and exit.
if self.mode == 'info':
# Initialise the information box.
info = Info_box()
# Print the program intro.
print(info.intro_text())
# Print the system info.
print(info.sys_info())
# Stop execution.
return
# Run the interpreter for the prompt or script modes.
if self.mode == 'prompt' or self.mode == 'script':
# Run the interpreter.
self.interpreter = interpreter.Interpreter()
self.interpreter.run(self.script_file)
# Execute the relax GUI.
elif self.mode == 'gui':
# Dependency check.
if not dep_check.wx_module:
sys.stderr.write("Please install the wx Python module to access the relax GUI.\n\n")
return
# Only import the module in this mode (to improve program start up speeds).
import gui
# Set the GUI flag in the status object.
status.show_gui = True
# Start the relax GUI wx application.
app = gui.App(script_file=self.script_file)
app.MainLoop()
# Execute the relax test suite
elif self.mode == 'test suite':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False, raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_all_tests()
# Execute the relax system tests.
elif self.mode == 'system tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False, raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_system_tests()
# Execute the relax unit tests.
elif self.mode == 'unit tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_unit_tests()
# Execute the relax GUI tests.
elif self.mode == 'GUI tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_gui_tests()
# Execute the relax verification tests.
elif self.mode == 'verification tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_verification_tests()
# Test mode.
elif self.mode == 'test':
self.test_mode()
# Licence mode.
elif self.mode == 'licence':
self.licence()
# Unknown mode.
else:
raise lib.errors.RelaxError("The '%s' mode is unknown." % self.mode)
def start(mode=None, profile_flag=False):
"""Execute relax.
@keyword mode: Force a relax mode, overriding the command line.
@type mode: str
@keyword profile_flag: Change this flag to True for code profiling.
@type profile_flag: bool
"""
# Normal relax operation.
relax = Relax()
# Override normal operation.
if mode:
# Override the mode.
relax.mode = mode
# Some defaults.
relax.script_file = None
relax.log_file = None
relax.tee_file = None
relax.multiprocessor_type = 'uni'
relax.n_processors = 1
# Process the command line arguments.
else:
relax.arguments()
# Store some start up info in the status object.
status.relax_mode = relax.mode
# Set up the multi-processor elements.
callbacks = Application_callback(master=relax)
verbosity = 0
if status.debug:
verbosity = 1
processor = load_multiprocessor(relax.multiprocessor_type,
callbacks,
processor_size=relax.n_processors,
verbosity=verbosity)
# Place the processor fabric intro string into the info box.
info = Info_box()
info.multi_processor_string = processor.get_intro_string()
# Normal relax operation.
if not profile_flag:
# Execute relax in multi-processor mode (this includes the uni-processor for normal operation).
processor.run()
# relax in profiling mode.
else:
def print_stats(stats, status=0):
pstats.Stats(stats).sort_stats('time', 'name').print_stats()
# No profile module.
if not dep_check.profile_module:
sys.stderr.write(
"The profile module is not available, please install the Python development packages for profiling.\n\n"
)
sys.exit()
# Run relax in profiling mode.
profile.Profile.print_stats = print_stats
profile.runctx('processor.run()', globals(), locals())
def run(self):
"""Execute relax.
This is the application callback method executed by the multi-processor framework.
"""
# Set up the warning system.
lib.warnings.setup()
# Logging.
if self.log_file:
io_streams_log(self.log_file)
# Tee.
elif self.tee_file:
io_streams_tee(self.tee_file)
# Show the version number and exit.
if self.mode == 'version':
print('relax ' + version.version_full())
return
# Show the relax info and exit.
if self.mode == 'info':
# Initialise the information box.
info = Info_box()
# Print the program intro.
print(info.intro_text())
# Print the system info.
print(info.sys_info())
# Stop execution.
return
# Run the interpreter for the prompt or script modes.
if self.mode == 'prompt' or self.mode == 'script':
# Run the interpreter.
self.interpreter = interpreter.Interpreter()
self.interpreter.run(self.script_file)
# Execute the relax GUI.
elif self.mode == 'gui':
# Dependency check.
if not dep_check.wx_module:
sys.stderr.write(
"Please install the wx Python module to access the relax GUI.\n\n"
)
return
# Only import the module in this mode (to improve program start up speeds).
import gui
# Set the GUI flag in the status object.
status.show_gui = True
# Start the relax GUI wx application.
app = gui.App(script_file=self.script_file)
app.MainLoop()
# Execute the relax test suite
elif self.mode == 'test suite':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False,
raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_all_tests()
# Execute the relax system tests.
elif self.mode == 'system tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Load the interpreter and turn intros on.
self.interpreter = interpreter.Interpreter(show_script=False,
raise_relax_error=True)
self.interpreter.on()
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_system_tests()
# Execute the relax unit tests.
elif self.mode == 'unit tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_unit_tests()
# Execute the relax GUI tests.
elif self.mode == 'GUI tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_gui_tests()
# Execute the relax verification tests.
elif self.mode == 'verification tests':
# Only import the module in the test modes (to improve program start up speeds).
from test_suite.test_suite_runner import Test_suite_runner
# Run the tests.
runner = Test_suite_runner(self.tests, timing=self.test_timings)
runner.run_verification_tests()
# Test mode.
elif self.mode == 'test':
self.test_mode()
# Licence mode.
elif self.mode == 'licence':
self.licence()
# Unknown mode.
else:
raise lib.errors.RelaxError("The '%s' mode is unknown." %
self.mode)
def __init__(self, gui):
"""Set up the relax controller frame.
@param gui: The GUI object.
@type gui: wx.Frame instance
"""
# Store the args.
self.gui = gui
# Initialise the base class.
super(Controller, self).__init__(self.gui,
-1,
style=wx.DEFAULT_FRAME_STYLE)
# Some default values.
self.size_x = 800
self.size_y = 700
self.border = 5
self.spacer = 10
# Set up the frame.
sizer = self.setup_frame()
# Add the relax logo.
self.add_relax_logo(sizer)
# Spacing.
sizer.AddSpacer(20)
# Add the current analysis info.
self.name = self.add_text(self.main_panel, sizer,
"Current GUI analysis:")
# Add the current data pipe info.
self.cdp = self.add_text(self.main_panel, sizer, "Current data pipe:")
# Create the relaxation curve-fitting specific panel.
self.create_rx(sizer)
# Create the model-free specific panel.
self.create_mf(sizer)
# Add the main execution gauge.
self.main_gauge = self.add_gauge(
self.main_panel,
sizer,
"Execution progress:",
tooltip=
"This gauge will pulse while relax is executing an auto-analysis (when the execution lock is turned on) and will be set to 100% once the analysis is complete."
)
# Initialise a queue for log messages.
self.log_queue = Queue()
# Add the log panel.
self.log_panel = LogCtrl(self.main_panel,
self,
log_queue=self.log_queue,
id=-1)
sizer.Add(self.log_panel, 1, wx.EXPAND | wx.ALL, 0)
# IO redirection for STDOUT (with splitting if logging or teeing modes are set).
out = Redirect_text(self.log_panel,
self.log_queue,
orig_io=sys.stdout,
stream=0)
if sys.stdout == sys.__stdout__ or status.relax_mode in [
'test suite', 'system tests', 'unit tests', 'GUI tests'
]:
sys.stdout = out
else:
split_stdout = SplitIO()
split_stdout.split(sys.stdout, out)
sys.stdout = split_stdout
# IO redirection for STDERR (with splitting if logging or teeing modes are set).
err = Redirect_text(self.log_panel,
self.log_queue,
orig_io=sys.stderr,
stream=1)
if sys.stderr == sys.__stderr__ or status.relax_mode in [
'test suite', 'system tests', 'unit tests', 'GUI tests'
]:
sys.stderr = err
else:
split_stderr = SplitIO()
split_stderr.split(sys.stderr, err)
sys.stderr = split_stderr
# Initial update of the controller.
self.update_controller()
# Create a timer for updating the controller elements.
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.handler_timer, self.timer)
# The relax intro printout, to mimic the prompt/script interface.
if not status.test_mode:
info = Info_box()
sys.stdout.write(info.intro_text())
sys.stdout.write("\n")
sys.stdout.flush()
# Set the focus on the log control.
self.log_panel.SetFocus()
# Register functions with the observer objects.
status.observers.pipe_alteration.register(
'controller',
self.update_controller,
method_name='update_controller')
status.observers.auto_analyses.register(
'controller',
self.update_controller,
method_name='update_controller')
status.observers.gui_analysis.register('controller',
self.update_controller,
method_name='update_controller')
status.observers.exec_lock.register('controller',
self.update_gauge,
method_name='update_gauge')
def __init__(self, gui):
"""Set up the relax controller frame.
@param gui: The GUI object.
@type gui: wx.Frame instance
"""
# Store the args.
self.gui = gui
# Initialise the base class.
super(Controller, self).__init__(self.gui, -1, style=wx.DEFAULT_FRAME_STYLE)
# Some default values.
self.size_x = 800
self.size_y = 700
self.border = 5
self.spacer = 10
# Set up the frame.
sizer = self.setup_frame()
# Add the relax logo.
self.add_relax_logo(sizer)
# Spacing.
sizer.AddSpacer(20)
# Add the current analysis info.
self.name = self.add_text(self.main_panel, sizer, "Current GUI analysis:")
# Add the current data pipe info.
self.cdp = self.add_text(self.main_panel, sizer, "Current data pipe:")
# Create the relaxation curve-fitting specific panel.
self.create_rx(sizer)
# Create the model-free specific panel.
self.create_mf(sizer)
# Add the main execution gauge.
self.main_gauge = self.add_gauge(self.main_panel, sizer, "Execution progress:", tooltip="This gauge will pulse while relax is executing an auto-analysis (when the execution lock is turned on) and will be set to 100% once the analysis is complete.")
# Initialise a queue for log messages.
self.log_queue = Queue()
# Add the log panel.
self.log_panel = LogCtrl(self.main_panel, self, log_queue=self.log_queue, id=-1)
sizer.Add(self.log_panel, 1, wx.EXPAND|wx.ALL, 0)
# IO redirection for STDOUT (with splitting if logging or teeing modes are set).
out = Redirect_text(self.log_panel, self.log_queue, orig_io=sys.stdout, stream=0)
if sys.stdout == sys.__stdout__ or status.relax_mode in ['test suite', 'system tests', 'unit tests', 'GUI tests']:
sys.stdout = out
else:
split_stdout = SplitIO()
split_stdout.split(sys.stdout, out)
sys.stdout = split_stdout
# IO redirection for STDERR (with splitting if logging or teeing modes are set).
err = Redirect_text(self.log_panel, self.log_queue, orig_io=sys.stderr, stream=1)
if sys.stderr == sys.__stderr__ or status.relax_mode in ['test suite', 'system tests', 'unit tests', 'GUI tests']:
sys.stderr = err
else:
split_stderr = SplitIO()
split_stderr.split(sys.stderr, err)
sys.stderr = split_stderr
# Initial update of the controller.
self.update_controller()
# Create a timer for updating the gauges.
self.timer = wx.Timer(self)
self.Bind(wx.EVT_TIMER, self.handler_timer, self.timer)
# The relax intro printout, to mimic the prompt/script interface.
if not status.test_mode:
info = Info_box()
print(info.intro_text())
# Register functions with the observer objects.
status.observers.pipe_alteration.register('controller', self.update_controller, method_name='update_controller')
status.observers.auto_analyses.register('controller', self.update_controller, method_name='update_controller')
status.observers.gui_analysis.register('controller', self.update_controller, method_name='update_controller')
status.observers.exec_lock.register('controller', self.update_gauge, method_name='update_gauge')
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)
