gui.analyses.auto_model

1 ############################################################################### 2 # # 3 # Copyright (C) 2009 Michael Bieri # 4 # Copyright (C) 2010-2014 Edward d'Auvergne # 5 # # 6 # This file is part of the program relax (http://www.nmr-relax.com). # 7 # # 8 # This program is free software: you can redistribute it and/or modify # 9 # it under the terms of the GNU General Public License as published by # 10 # the Free Software Foundation, either version 3 of the License, or # 11 # (at your option) any later version. # 12 # # 13 # This program is distributed in the hope that it will be useful, # 14 # but WITHOUT ANY WARRANTY; without even the implied warranty of # 15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # 16 # GNU General Public License for more details. # 17 # # 18 # You should have received a copy of the GNU General Public License # 19 # along with this program. If not, see <http://www.gnu.org/licenses/>. # 20 # # 21 ############################################################################### 22 23 # Module docstring. 24 """Module for the automatic model-free protocol frame.""" 25 26 # Python module imports. 27 from math import ceil 28 from os import sep 29 import wx 30 import wx.lib.buttons 31 import wx.lib.mixins.listctrl 32 33 # relax module imports. 34 from auto_analyses import dauvergne_protocol 35 from data_store import Relax_data_store; ds = Relax_data_store() 36 from graphics import ANALYSIS_IMAGE_PATH, IMAGE_PATH, fetch_icon 37 from gui.about import About_base 38 from gui.analyses.base import Base_analysis 39 from gui.analyses.elements.spin_element import Spin_ctrl 40 from gui.analyses.elements.text_element import Text_ctrl 41 from gui.analyses.execute import Execute 42 from gui.analyses.elements.model_list import Model_list 43 from gui.base_classes import Container 44 from gui.components.relax_data import Relax_data_list 45 from gui.filedialog import RelaxDirDialog 46 from gui.fonts import font 47 from gui.message import error_message, Missing_data 48 from gui.misc import add_border, bitmap_setup 49 from gui.string_conv import gui_to_int, gui_to_str, str_to_gui 50 from gui.uf_objects import Uf_storage; uf_store = Uf_storage() 51 from gui.wizards.wiz_objects import Wiz_window 52 from lib.physical_constants import NH_BOND_LENGTH 53 from lib.errors import RelaxError 54 from lib.text.gui import local_tm, rex, s2, s2f, te, tf, tm, ts 55 from lib.text.string import LIST, PARAGRAPH, SECTION, SUBSECTION, TITLE 56 from pipe_control.interatomic import interatomic_loop 57 from pipe_control.mol_res_spin import exists_mol_res_spin_data, return_spin, spin_loop 58 from pipe_control.pipes import has_bundle, has_pipe 59 from specific_analyses.api import return_api 60 from status import Status; status = Status() 61 62

63 -class About_window(About_base):

64 """The model-free about window.""" 65 66 # The relax background colour. 67 colour1 = '#e5feff' 68 colour2 = '#88cbff' 69 70 # Dimensions. 71 dim_x = 800 72 dim_y = 800 73 max_y = 2500 74 75 # Spacer size (px). 76 border = 10 77 78 # Window style. 79 style = wx.DEFAULT_DIALOG_STYLE 80 81 # Destroy on clicking. 82 DESTROY_ON_CLICK = False 83

84 - def __init__(self, parent):

85 """Set up the user function class.""" 86 87 # Execute the base class method. 88 super(About_window, self).__init__(parent, id=-1, title="Automatic model-free analysis about window")

89 90

91 - def build_widget(self):

92 """Build the dialog using the dauvergne_protocol docstring.""" 93 94 # A global Y offset for packing the elements together (initialise to the border position). 95 self.offset(self.border) 96 97 # Loop over the lines. 98 for i in range(len(dauvergne_protocol.doc)): 99 # The level and text. 100 level, text = dauvergne_protocol.doc[i] 101 102 # The title. 103 if level == TITLE: 104 self.draw_title(text, alt_font=font.roman_font_18) 105 106 # The section. 107 elif level == SECTION: 108 self.draw_title(text, alt_font=font.roman_font_14) 109 110 # The section. 111 elif level == SUBSECTION: 112 self.draw_title(text, alt_font=font.roman_font_12) 113 114 # Paragraphs. 115 elif level == PARAGRAPH: 116 self.draw_wrapped_text(text) 117 118 # Lists. 119 elif level == LIST: 120 # Start of list. 121 if i and dauvergne_protocol.doc[i-1][0] != LIST: 122 self.offset(10) 123 124 # The text. 125 self.draw_wrapped_text(" - %s" % text) 126 127 # End of list. 128 if i < len(dauvergne_protocol.doc) and dauvergne_protocol.doc[i+1][0] == PARAGRAPH: 129 self.offset(10) 130 131 # Add space to the bottom. 132 self.offset(self.border) 133 134 # Round the offset up to the nearest factor of the scroll inc (needed for all scrolling). 135 scroll_x, scroll_y = self.window.GetScrollPixelsPerUnit() 136 y = self.offset() 137 self.offset(-y) 138 y = int(ceil(y/float(scroll_y)) * scroll_y) 139 self.offset(y) 140 141 # Resize the window. 142 dim_x = self.dim_x 143 virt_y = self.offset() 144 self.SetSize((dim_x, self.dim_y)) 145 self.window.SetVirtualSize((dim_x, virt_y)) 146 self.window.EnableScrolling(x_scrolling=False, y_scrolling=True)

147 148 149

150 -class Auto_model_free(Base_analysis):

151 """The model-free auto-analysis GUI element.""" 152

153 - def __init__(self, parent, id=-1, pos=wx.Point(-1, -1), size=wx.Size(-1, -1), style=524288, name='scrolledpanel', gui=None, analysis_name=None, pipe_name=None, pipe_bundle=None, uf_exec=[], data_index=None):

154 """Build the automatic model-free protocol GUI element. 155 156 @param parent: The parent wx element. 157 @type parent: wx object 158 @keyword id: The unique ID number. 159 @type id: int 160 @keyword pos: The position. 161 @type pos: wx.Size object 162 @keyword size: The size. 163 @type size: wx.Size object 164 @keyword style: The style. 165 @type style: int 166 @keyword name: The name for the panel. 167 @type name: unicode 168 @keyword gui: The main GUI class. 169 @type gui: gui.relax_gui.Main instance 170 @keyword analysis_name: The name of the analysis (the name in the tab part of the notebook). 171 @type analysis_name: str 172 @keyword pipe_name: The name of the original data pipe for this analysis. 173 @type pipe_name: str 174 @keyword pipe_bundle: The name of the data pipe bundle associated with this analysis. 175 @type pipe_bundle: str 176 @keyword uf_exec: The list of user function on_execute methods returned from the new analysis wizard. 177 @type uf_exec: list of methods 178 @keyword data_index: The index of the analysis in the relax data store (set to None if no data currently exists). 179 @type data_index: None or int 180 """ 181 182 # Store the GUI main class. 183 self.gui = gui 184 185 # Init. 186 self.init_flag = True 187 188 # New data container. 189 if data_index == None: 190 # First create the data pipe if not already in existence. 191 if not has_pipe(pipe_name): 192 self.gui.interpreter.apply('pipe.create', pipe_name=pipe_name, pipe_type='mf', bundle=pipe_bundle) 193 194 # Create the data pipe bundle if needed. 195 if not has_bundle(pipe_bundle): 196 self.gui.interpreter.apply('pipe.bundle', bundle=pipe_bundle, pipe=pipe_name) 197 198 # Generate a storage container in the relax data store, and alias it for easy access. 199 data_index = ds.relax_gui.analyses.add('model-free') 200 201 # Store the analysis and pipe names. 202 ds.relax_gui.analyses[data_index].analysis_name = analysis_name 203 ds.relax_gui.analyses[data_index].pipe_name = pipe_name 204 ds.relax_gui.analyses[data_index].pipe_bundle = pipe_bundle 205 206 # Initialise the variables. 207 ds.relax_gui.analyses[data_index].grid_inc = None 208 ds.relax_gui.analyses[data_index].diff_tensor_grid_inc = {'sphere': 11, 'prolate': 11, 'oblate': 11, 'ellipsoid': 6} 209 ds.relax_gui.analyses[data_index].mc_sim_num = None 210 ds.relax_gui.analyses[data_index].save_dir = self.gui.launch_dir 211 ds.relax_gui.analyses[data_index].local_tm_models = ['tm0', 'tm1', 'tm2', 'tm3', 'tm4', 'tm5', 'tm6', 'tm7', 'tm8', 'tm9'] 212 ds.relax_gui.analyses[data_index].mf_models = ['m0', 'm1', 'm2', 'm3', 'm4', 'm5', 'm6', 'm7', 'm8', 'm9'] 213 ds.relax_gui.analyses[data_index].max_iter = 30 214 215 # Error checking. 216 if ds.relax_gui.analyses[data_index].pipe_bundle == None: 217 raise RelaxError("The pipe bundle must be supplied.") 218 219 # Alias the data. 220 self.data = ds.relax_gui.analyses[data_index] 221 self.data_index = data_index 222 223 # Backward compatibility. 224 if not hasattr(self.data, 'local_tm_models'): 225 self.data.local_tm_models = ['tm0', 'tm1', 'tm2', 'tm3', 'tm4', 'tm5', 'tm6', 'tm7', 'tm8', 'tm9'] 226 if not hasattr(self.data, 'mf_models'): 227 self.data.mf_models = ['m0', 'm1', 'm2', 'm3', 'm4', 'm5', 'm6', 'm7', 'm8', 'm9'] 228 229 # Initialise the mode selection window. 230 self.mode_win = Protocol_mode_sel_window() 231 232 # Register the method for updating the spin count for the completion of user functions. 233 self.observer_register() 234 235 # Execute the base class method to build the panel. 236 super(Auto_model_free, self).__init__(parent, id=id, pos=pos, size=size, style=style, name=name)

237 238

239 - def _about(self, event=None):

240 """The about window. 241 242 @keyword event: The wx event. 243 @type event: wx event 244 """ 245 246 # Initialise the dialog. 247 self.about_dialog = About_window(self) 248 249 # Show the dialog. 250 if status.show_gui: 251 self.about_dialog.Show()

252 253

254 - def activate(self):

255 """Activate or deactivate certain elements of the analysis in response to the execution lock.""" 256 257 # Flag for enabling or disabling the elements. 258 enable = False 259 if not status.exec_lock.locked(): 260 enable = True 261 262 # Activate or deactivate the elements. 263 wx.CallAfter(self.field_results_dir.Enable, enable) 264 wx.CallAfter(self.spin_systems.Enable, enable) 265 wx.CallAfter(self.relax_data.Enable, enable) 266 wx.CallAfter(self.button_dipole_pair.Enable, enable) 267 wx.CallAfter(self.button_csa.Enable, enable) 268 wx.CallAfter(self.button_isotope_heteronuc.Enable, enable) 269 wx.CallAfter(self.button_isotope_proton.Enable, enable) 270 wx.CallAfter(self.local_tm_model_field.Enable, enable) 271 wx.CallAfter(self.mf_model_field.Enable, enable) 272 wx.CallAfter(self.grid_inc.Enable, enable) 273 wx.CallAfter(self.mc_sim_num.Enable, enable) 274 wx.CallAfter(self.max_iter.Enable, enable) 275 wx.CallAfter(self.mode.Enable, enable) 276 wx.CallAfter(self.button_exec_relax.Enable, enable)

277 278

279 - def add_values(self, box):

280 """Create and add the value.set buttons for the model-free analysis. 281 282 @param box: The box element to pack the GUI element into. 283 @type box: wx.BoxSizer instance 284 """ 285 286 # Sizer. 287 sizer = wx.BoxSizer(wx.HORIZONTAL) 288 289 # Dipole-dipole relaxation setup button. 290 self.button_dipole_pair = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, " Dipolar relaxation") 291 self.button_dipole_pair.SetBitmapLabel(wx.Bitmap(fetch_icon("relax.dipole_pair", "22x22"), wx.BITMAP_TYPE_ANY)) 292 self.button_dipole_pair.SetFont(font.normal) 293 self.button_dipole_pair.SetSize((-1, 25)) 294 self.button_dipole_pair.SetToolTipString("Define the magnetic dipole-dipole relaxation mechanism.") 295 self.gui.Bind(wx.EVT_BUTTON, self.setup_dipole_pair, self.button_dipole_pair) 296 sizer.Add(self.button_dipole_pair, 1, wx.ALL|wx.EXPAND, 0) 297 298 # CSA button. 299 self.button_csa = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, " CSA relaxation") 300 self.button_csa.SetBitmapLabel(wx.Bitmap(fetch_icon("relax.align_tensor", "22x22"), wx.BITMAP_TYPE_ANY)) 301 self.button_csa.SetFont(font.normal) 302 self.button_csa.SetSize((-1, 25)) 303 self.button_csa.SetToolTipString("Define the Chemical Shift Anisotropy (CSA) relaxation mechanism via the value.set user function.") 304 self.gui.Bind(wx.EVT_BUTTON, self.value_set_csa, self.button_csa) 305 sizer.Add(self.button_csa, 1, wx.ALL|wx.EXPAND, 0) 306 307 # Isotope type button (heteronucleus). 308 self.button_isotope_heteronuc = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, " X isotope") 309 self.button_isotope_heteronuc.SetBitmapLabel(wx.Bitmap(fetch_icon("relax.nuclear_symbol", "22x22"), wx.BITMAP_TYPE_ANY)) 310 self.button_isotope_heteronuc.SetFont(font.normal) 311 self.button_isotope_heteronuc.SetSize((-1, 25)) 312 self.button_isotope_heteronuc.SetToolTipString("Set the nuclear isotope types of the heteronuclear spins via the spin.isotope user function.") 313 self.gui.Bind(wx.EVT_BUTTON, self.spin_isotope_heteronuc, self.button_isotope_heteronuc) 314 sizer.Add(self.button_isotope_heteronuc, 1, wx.ALL|wx.EXPAND, 0) 315 316 # Isotope type button (proton). 317 self.button_isotope_proton = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, " H isotope") 318 self.button_isotope_proton.SetBitmapLabel(wx.Bitmap(fetch_icon("relax.nuclear_symbol", "22x22"), wx.BITMAP_TYPE_ANY)) 319 self.button_isotope_proton.SetFont(font.normal) 320 self.button_isotope_proton.SetSize((-1, 25)) 321 self.button_isotope_proton.SetToolTipString("Set the nuclear isotope types of the proton spins via the spin.isotope user function.") 322 self.gui.Bind(wx.EVT_BUTTON, self.spin_isotope_proton, self.button_isotope_proton) 323 sizer.Add(self.button_isotope_proton, 1, wx.ALL|wx.EXPAND, 0) 324 325 # Add the element to the box. 326 box.Add(sizer, 0, wx.ALL|wx.EXPAND, 0)

327 328

329 - def assemble_data(self):

330 """Assemble the data required for the auto-analysis. 331 332 See the docstring for auto_analyses.dauvernge_protocol for details. All data is taken from the relax data store, so data upload from the GUI to there must have been previously performed. 333 334 @return: A container with all the data required for the auto-analysis. 335 @rtype: class instance, list of str 336 """ 337 338 # The data container. 339 data = Container() 340 missing = [] 341 342 # The pipe name and bundle. 343 data.pipe_name = self.data.pipe_name 344 data.pipe_bundle = self.data.pipe_bundle 345 346 # The model-free models (do not change these unless absolutely necessary). 347 data.local_tm_models = self.local_tm_model_field.GetValue() 348 data.mf_models = self.mf_model_field.GetValue() 349 350 # Automatic looping over all rounds until convergence (must be a boolean value of True or False). 351 data.conv_loop = True 352 353 # Increment size. 354 data.inc = gui_to_int(self.grid_inc.GetValue()) 355 if hasattr(self.data, 'diff_tensor_grid_inc'): 356 data.diff_tensor_grid_inc = self.data.diff_tensor_grid_inc 357 else: 358 data.diff_tensor_grid_inc = {'sphere': 11, 'prolate': 11, 'oblate': 11, 'ellipsoid': 6} 359 360 # The number of Monte Carlo simulations to be used for error analysis at the end of the analysis. 361 data.mc_sim_num = gui_to_int(self.mc_sim_num.GetValue()) 362 363 # Number of maximum iterations. 364 data.max_iter = self.data.max_iter 365 366 # Results directory. 367 data.save_dir = self.data.save_dir 368 369 # Check if sequence data is loaded 370 if not exists_mol_res_spin_data(): 371 missing.append("Sequence data") 372 373 # Relaxation data. 374 if not hasattr(cdp, 'ri_ids') or len(cdp.ri_ids) == 0: 375 missing.append("Relaxation data") 376 377 # Insufficient data. 378 if hasattr(cdp, 'ri_ids') and len(cdp.ri_ids) <= 3: 379 missing.append("Insufficient relaxation data, 4 or more data sets are essential for the execution of the dauvergne_protocol auto-analysis. Check that you have entered data for a least two spectrometer fields.") 380 381 # Interatomic data containers. 382 if not hasattr(cdp, 'interatomic') or len(cdp.interatomic) == 0: 383 missing.append("Interatomic data (for the dipole-dipole interaction)") 384 385 # Get the mode. 386 mode = gui_to_str(self.mode.GetValue()) 387 388 # Solve for all global models. 389 if mode == 'Fully automated': 390 # The global model list. 391 data.global_models = ['local_tm', 'sphere', 'prolate', 'oblate', 'ellipsoid', 'final'] 392 393 # Any global model selected. 394 else: 395 data.global_models = [mode] 396 397 # Check for vectors. 398 vector_check = False 399 if 'prolate' in data.global_models or 'oblate' in data.global_models or 'ellipsoid' in data.global_models: 400 vector_check = True 401 402 # Spin variables. 403 for spin, spin_id in spin_loop(return_id=True): 404 # Skip deselected spins. 405 if not spin.select: 406 continue 407 408 # The message skeleton. 409 msg = "Spin '%s' - %s (try the %s user function)." % (spin_id, "%s", "%s") 410 411 # Test if the nuclear isotope type has been set. 412 if not hasattr(spin, 'isotope') or spin.isotope == None: 413 missing.append(msg % ("nuclear isotope data", "spin.isotope")) 414 415 # Test if the CSA value has been set for the heteronuclei. 416 if (hasattr(spin, 'isotope') and spin.isotope in ['15N', '13C']) and (not hasattr(spin, 'csa') or spin.csa == None): 417 missing.append(msg % ("CSA data", "value.set")) 418 419 # Interatomic data container variables. 420 for interatom in interatomic_loop(): 421 # Get the spin containers. 422 spin1 = return_spin(interatom.spin_id1) 423 spin2 = return_spin(interatom.spin_id2) 424 425 # Skip deselected spins. 426 if not spin1.select: 427 continue 428 if not spin2.select: 429 continue 430 431 # The message skeleton. 432 msg = "Spin pair '%s' and '%s' - %s (try the %s user function)." % (interatom.spin_id1, interatom.spin_id2, "%s", "%s") 433 434 # Test if the interatomic distance has been set. 435 if not hasattr(interatom, 'r') or interatom.r == None: 436 missing.append(msg % ("bond length data", "value.set")) 437 438 # Test if the unit vectors have been loaded. 439 if vector_check and (not hasattr(interatom, 'vector') or interatom.vector == None): 440 missing.append(msg % ("unit vectors", "interatom.unit_vectors")) 441 442 # Return the container and list of missing data. 443 return data, missing

444 445

446 - def build_left_box(self):

447 """Construct the left hand box to pack into the main model-free box. 448 449 @return: The left hand box element containing the bitmap and about button to pack into the main model-free box. 450 @rtype: wx.BoxSizer instance 451 """ 452 453 # Build the left hand box. 454 left_box = wx.BoxSizer(wx.VERTICAL) 455 456 # The images. 457 bitmaps = [ANALYSIS_IMAGE_PATH+"model_free"+sep+"model_free_200x200.png", 458 IMAGE_PATH+'modelfree.png'] 459 460 # Add the model-free bitmap picture. 461 for i in range(len(bitmaps)): 462 # The bitmap. 463 bitmap = wx.StaticBitmap(self, -1, bitmap_setup(bitmaps[i])) 464 465 # Add it. 466 left_box.Add(bitmap, 0, wx.ALL, 0) 467 468 # A spacer. 469 left_box.AddStretchSpacer() 470 471 # A button sizer, with some initial spacing. 472 button_sizer = wx.BoxSizer(wx.HORIZONTAL) 473 474 # An about button. 475 button = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, "About") 476 button.SetBitmapLabel(wx.Bitmap(fetch_icon('oxygen.actions.help-about', "22x22"), wx.BITMAP_TYPE_ANY)) 477 button.SetFont(font.normal) 478 button.SetToolTipString("Information about this automatic analysis") 479 480 # Bind the click. 481 self.Bind(wx.EVT_BUTTON, self._about, button) 482 483 # A cursor for the button. 484 cursor = wx.StockCursor(wx.CURSOR_QUESTION_ARROW) 485 button.SetCursor(cursor) 486 487 # Pack the button. 488 button_sizer.Add(button, 0, 0, 0) 489 left_box.Add(button_sizer, 0, wx.ALL, 0) 490 491 # Return the packed box. 492 return left_box

493 494

495 - def build_right_box(self):

496 """Construct the right hand box to pack into the main model-free box. 497 498 @return: The right hand box element containing all model-free GUI elements (excluding the bitmap) to pack into the main model-free box. 499 @rtype: wx.BoxSizer instance 500 """ 501 502 # Use a vertical packing of elements. 503 box = wx.BoxSizer(wx.VERTICAL) 504 505 # Add the frame title. 506 self.add_title(box, "Model-free analysis") 507 508 # Display the data pipe. 509 Text_ctrl(box, self, text="The data pipe bundle:", default=self.data.pipe_bundle, tooltip="This is the data pipe bundle associated with this analysis.", editable=False, width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 510 511 # Add the results directory GUI element. 512 self.field_results_dir = Text_ctrl(box, self, text="Results directory:", icon=fetch_icon('oxygen.actions.document-open-folder', "16x16"), default=self.data.save_dir, tooltip="The directory in which all automatically created files will be saved.", tooltip_button="Select the results directory.", fn=self.results_directory, button=True, width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 513 514 # Add the spin GUI element. 515 self.add_spin_systems(box, self) 516 517 # Add the relaxation data list GUI element, with spacing. 518 box.AddSpacer(10) 519 self.relax_data = Relax_data_list(gui=self.gui, parent=self, box=box, id=str(self.data_index)) 520 box.AddSpacer(10) 521 522 # Add the value.set buttons. 523 self.add_values(box) 524 box.AddSpacer(10) 525 526 # Add the local tau_m models GUI element, with spacing. 527 self.local_tm_model_field = Local_tm_list(self, box) 528 self.local_tm_model_field.set_value(self.data.local_tm_models) 529 530 # Add the model-free models GUI element, with spacing. 531 self.mf_model_field = Mf_list(self, box) 532 self.mf_model_field.set_value(self.data.mf_models) 533 534 # The optimisation settings. 535 self.grid_inc = Spin_ctrl(box, self, text="Grid search increments:", default=11, min=1, max=100, tooltip="This is the number of increments per dimension of the grid search performed prior to numerical optimisation.", width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 536 self.mc_sim_num = Spin_ctrl(box, self, text="Monte Carlo simulation number:", default=500, min=1, max=100000, tooltip="This is the number of Monte Carlo simulations performed for error propagation and analysis.", width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 537 538 # Add maximum iteration selector. 539 self.max_iter = Spin_ctrl(box, self, text="Maximum iterations:", default=self.data.max_iter, tooltip="The maximum number of iterations for the protocol. This is the limit for the global looping over the optimisation of the model-free models, model elimination, model selection and then optimisation of the diffusion tensor.", min=25, max=100, width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 540 541 # The calculation mode. 542 self.mode = Text_ctrl(box, self, text="Protocol mode:", default='Fully automated', tooltip="Select if the dauvergne_protocol analysis will be fully automated or whether the individual global models will be optimised separately.", tooltip_button="Open the protocol mode selection window.", icon=fetch_icon('oxygen.actions.system-run', "16x16"), fn=self.mode_dialog, editable=False, button=True, width_text=self.width_text, width_button=self.width_button, spacer=self.spacer_horizontal) 543 544 # Stretchable spacing (with a minimal space). 545 box.AddSpacer(30) 546 box.AddStretchSpacer() 547 548 # Add the execution GUI element. 549 self.button_exec_relax = self.add_execute_analysis(box, self.execute) 550 551 # Return the box. 552 return box

553 554

555 - def delete(self):

556 """Unregister the spin count from the user functions.""" 557 558 # Unregister the observer methods. 559 self.observer_register(remove=True) 560 561 # Clean up the relaxation data list object. 562 self.relax_data.delete()

563 564

565 - def execute(self, event=None):

566 """Set up, execute, and process the automatic model-free protocol. 567 568 @keyword event: The wx event. 569 @type event: wx event 570 """ 571 572 # Flush the GUI interpreter internal queue to make sure all user functions are complete. 573 self.gui.interpreter.flush() 574 575 # relax execution lock. 576 if status.exec_lock.locked(): 577 error_message("relax is currently executing.", "relax execution lock") 578 event.Skip() 579 return 580 581 # User warning to close windows. 582 self.gui.close_windows() 583 584 # Synchronise the frame data to the relax data store. 585 self.sync_ds(upload=True) 586 587 # Assemble all the data needed for the auto-analysis. 588 data, missing = self.assemble_data() 589 590 # Missing data. 591 if len(missing): 592 Missing_data(missing) 593 return 594 595 # Display the relax controller, and go to the end of the log window. 596 self.gui.show_controller(None) 597 self.gui.controller.log_panel.on_goto_end(None) 598 599 # Start the thread. 600 self.thread = Execute_mf(self.gui, data, self.data_index) 601 self.thread.start() 602 603 # Terminate the event. 604 event.Skip()

605 606

607 - def mode_dialog(self, event=None):

608 """The calculation mode selection. 609 610 @keyword event: The wx event. 611 @type event: wx event 612 """ 613 614 # Show the model selector window. 615 if status.show_gui: 616 self.mode_win.ShowModal() 617 618 # Set the model. 619 self.mode.SetValue(str_to_gui(self.mode_win.select))

620 621

622 - def observer_register(self, remove=False):

623 """Register and unregister methods with the observer objects. 624 625 @keyword remove: If set to True, then the methods will be unregistered. 626 @type remove: False 627 """ 628 629 # Register. 630 if not remove: 631 status.observers.gui_uf.register(self.data.pipe_bundle, self.update_spin_count, method_name='update_spin_count') 632 status.observers.exec_lock.register(self.data.pipe_bundle, self.activate, method_name='activate') 633 634 # Unregister. 635 else: 636 # The model-free methods. 637 status.observers.gui_uf.unregister(self.data.pipe_bundle) 638 status.observers.exec_lock.unregister(self.data.pipe_bundle) 639 640 # The embedded objects methods. 641 self.relax_data.observer_register(remove=True)

642 643

644 - def results_directory(self, event=None):

645 """The results directory selection. 646 647 @keyword event: The wx event. 648 @type event: wx event 649 """ 650 651 # The dialog. 652 dialog = RelaxDirDialog(parent=self, message='Select the results directory', defaultPath=self.field_results_dir.GetValue()) 653 654 # Show the dialog and catch if no file has been selected. 655 if status.show_gui and dialog.ShowModal() != wx.ID_OK: 656 # Don't do anything. 657 return 658 659 # The path (don't do anything if not set). 660 path = gui_to_str(dialog.get_path()) 661 if not path: 662 return 663 664 # Store the path. 665 self.data.save_dir = path 666 667 # Place the path in the text box. 668 self.field_results_dir.SetValue(str_to_gui(path))

669 670

671 - def setup_dipole_pair(self, event=None):

672 """Create the wizard for the dipole-dipole interaction. 673 674 @keyword event: The wx event. 675 @type event: wx event 676 """ 677 678 # Change the cursor to busy. 679 wx.BeginBusyCursor() 680 681 # Create the wizard. 682 self.dipole_wizard = Wiz_window(parent=self.gui, size_x=1000, size_y=750, title="Dipole-dipole interaction setup") 683 684 # Structural data. 685 if not hasattr(cdp, 'structure'): 686 # Create the PDB reading page. 687 page = uf_store['structure.read_pdb'].create_page(self.dipole_wizard, sync=True) 688 self.dipole_wizard.add_page(page, skip_button=True) 689 690 # Create the position reading page. 691 page = uf_store['structure.get_pos'].create_page(self.dipole_wizard, sync=True) 692 self.dipole_wizard.add_page(page, skip_button=True) 693 694 # Create the interatom.define page. 695 page = uf_store['interatom.define'].create_page(self.dipole_wizard, sync=True) 696 page.SetValue('spin_id1', '@N') 697 page.SetValue('spin_id2', '@H') 698 self.dipole_wizard.add_page(page) 699 700 # Create the interatom.set_dist page. 701 page = uf_store['interatom.set_dist'].create_page(self.dipole_wizard, sync=True) 702 page.SetValue('spin_id1', '@N*') 703 page.SetValue('spin_id2', '@H*') 704 page.SetValue('ave_dist', NH_BOND_LENGTH) 705 self.dipole_wizard.add_page(page) 706 707 # Create the interatom.unit_vectors page. 708 page = uf_store['interatom.unit_vectors'].create_page(self.dipole_wizard, sync=True) 709 self.dipole_wizard.add_page(page) 710 711 # Reset the cursor. 712 if wx.IsBusy(): 713 wx.EndBusyCursor() 714 715 # Execute the wizard. 716 self.dipole_wizard.run()

717 718

719 - def spin_isotope_heteronuc(self, event=None):

720 """Set the nuclear isotope types of the heteronuclear spins via the spin.isotope user function. 721 722 @keyword event: The wx event. 723 @type event: wx event 724 """ 725 726 # Call the user function. 727 uf_store['spin.isotope'](isotope='15N', spin_id='@N*')

728 729

730 - def spin_isotope_proton(self, event=None):

731 """Set the nuclear isotope types of the proton spins via the spin.isotope user function. 732 733 @keyword event: The wx event. 734 @type event: wx event 735 """ 736 737 # Call the user function. 738 uf_store['spin.isotope'](isotope='1H', spin_id='@H*')

739 740

741 - def sync_ds(self, upload=False):

742 """Synchronise the analysis frame and the relax data store, both ways. 743 744 This method allows the frame information to be uploaded into the relax data store, or for the information in the relax data store to be downloaded by the frame. 745 746 @keyword upload: A flag which if True will cause the frame to send data to the relax data store. If False, data will be downloaded from the relax data store to update the frame. 747 @type upload: bool 748 """ 749 750 # The local tau_m models to use. 751 if upload: 752 self.data.local_tm_models = self.local_tm_model_field.GetValue() 753 else: 754 self.local_tm_model_field.set_value(self.data.local_tm_models) 755 756 # The model-free models to use. 757 if upload: 758 self.data.mf_models = self.mf_model_field.GetValue() 759 else: 760 self.mf_model_field.set_value(self.data.mf_models) 761 762 # The grid incs. 763 if upload: 764 self.data.grid_inc = gui_to_int(self.grid_inc.GetValue()) 765 elif hasattr(self.data, 'grid_inc'): 766 self.grid_inc.SetValue(int(self.data.grid_inc)) 767 768 # The MC sim number. 769 if upload: 770 self.data.mc_sim_num = gui_to_int(self.mc_sim_num.GetValue()) 771 elif hasattr(self.data, 'mc_sim_num'): 772 self.mc_sim_num.SetValue(int(self.data.mc_sim_num)) 773 774 # The results directory. 775 if upload: 776 self.data.save_dir = str(self.field_results_dir.GetValue()) 777 else: 778 self.field_results_dir.SetValue(str_to_gui(self.data.save_dir)) 779 780 # Maximum iterations. 781 if upload: 782 self.data.max_iter = gui_to_int(self.max_iter.GetValue()) 783 else: 784 self.max_iter.SetValue(int(self.data.max_iter))

785 786

787 - def value_set_csa(self, event=None):

788 """Set the CSA via the value.set uf. 789 790 @keyword event: The wx event. 791 @type event: wx event 792 """ 793 794 # Get the default value. 795 api = return_api() 796 val = api.default_value('csa') 797 798 # Call the user function. 799 uf_store['value.set'](val=val, param='csa', spin_id='@N*')

800 801 802

803 -class Execute_mf(Execute):

804 """The model-free analysis execution object.""" 805

806 - def run_analysis(self):

807 """Execute the calculation.""" 808 809 # Start the protocol. 810 dauvergne_protocol.dAuvergne_protocol(pipe_name=self.data.pipe_name, pipe_bundle=self.data.pipe_bundle, results_dir=self.data.save_dir, diff_model=self.data.global_models, mf_models=self.data.mf_models, local_tm_models=self.data.local_tm_models, grid_inc=self.data.inc, diff_tensor_grid_inc=self.data.diff_tensor_grid_inc, mc_sim_num=self.data.mc_sim_num, max_iter=self.data.max_iter, conv_loop=self.data.conv_loop)

811 812 813

814 -class Local_tm_list(Model_list):

815 """The local model-free model list GUI element.""" 816 817 # Some class variables. 818 desc = "Local %s models:" % tm 819 model_desc = [ 820 "Model m0 with a local molecular correlation time (%s)." % tm, 821 "Model m1 with a local molecular correlation time (%s)." % tm, 822 "Model m2 with a local molecular correlation time (%s)." % tm, 823 "Model m3 with a local molecular correlation time (%s)." % tm, 824 "Model m4 with a local molecular correlation time (%s)." % tm, 825 "Model m5 with a local molecular correlation time (%s)." % tm, 826 "Model m6 with a local molecular correlation time (%s)." % tm, 827 "Model m7 with a local molecular correlation time (%s)." % tm, 828 "Model m8 with a local molecular correlation time (%s)." % tm, 829 "Model m9 with a local molecular correlation time (%s)." % tm 830 ] 831 models = [ 832 "tm0", 833 "tm1", 834 "tm2", 835 "tm3", 836 "tm4", 837 "tm5", 838 "tm6", 839 "tm7", 840 "tm8", 841 "tm9" 842 ] 843 params = [ 844 "{%s}" % local_tm, 845 "{%s, %s}" % (local_tm, s2), 846 "{%s, %s, %s}" % (local_tm, s2, te), 847 "{%s, %s, %s}" % (local_tm, s2, rex), 848 "{%s, %s, %s, %s}" % (local_tm, s2, te, rex), 849 "{%s, %s, %s, %s}" % (local_tm, s2, s2f, ts), 850 "{%s, %s, %s, %s, %s}" % (local_tm, s2, tf, s2f, ts), 851 "{%s, %s, %s, %s, %s}" % (local_tm, s2, s2f, ts, rex), 852 "{%s, %s, %s, %s, %s, %s}" % (local_tm, s2, tf, s2f, ts, rex), 853 "{%s, %s}" % (local_tm, rex) 854 ] 855 warning = "The model-free models used in dauvergne_protocol auto-analysis should almost never be changed! The consequences will be unpredictable. Please proceed only if you are sure of what you are doing. Would you like to modify the model-free model list?" 856 red_flag = True 857 size = wx.Size(680, 350) 858 tooltip = "The list model-free models with the %s parameter to optimise as the first step of the protocol (see the about window for details). This really should not be changed." % local_tm 859 tooltip_button = "Open the model list selector window."

860 861 862

863 -class Mf_list(Model_list):

864 """The model-free model list GUI element.""" 865 866 # Some class variables. 867 desc = "Model-free models:" 868 model_desc = [ 869 "No statistically significant internal motions.", 870 "The original model with a statistically insignificant %s." % te, 871 "The original Lipari and Szabo model.", 872 "The original model with chemical exchange relaxation but a statistically insignificant %s." % te, 873 "The original model with chemical exchange relaxation.", 874 "The extended model with a statistically insignificant %s." % tf, 875 "The Clore et al., 1991 extended model-free model.", 876 "The extended model with chemical exchange relaxation but a statistically insignificant %s." % tf, 877 "The extended model with chemical exchange relaxation.", 878 "No statistically significant internal motions but chemical exchange relaxation present." 879 ] 880 models = [ 881 "m0", 882 "m1", 883 "m2", 884 "m3", 885 "m4", 886 "m5", 887 "m6", 888 "m7", 889 "m8", 890 "m9" 891 ] 892 params = [ 893 "{}", 894 "{%s}" % s2, 895 "{%s, %s}" % (s2, te), 896 "{%s, %s}" % (s2, rex), 897 "{%s, %s, %s}" % (s2, te, rex), 898 "{%s, %s, %s}" % (s2, s2f, ts), 899 "{%s, %s, %s, %s}" % (s2, tf, s2f, ts), 900 "{%s, %s, %s, %s}" % (s2, s2f, ts, rex), 901 "{%s, %s, %s, %s, %s}" % (s2, tf, s2f, ts, rex), 902 "{%s}" % rex 903 ] 904 warning = "The model-free models used in dauvergne_protocol auto-analysis should almost never be changed! The consequences will be unpredictable. Please proceed only if you are sure of what you are doing. Would you like to modify the model-free model list?" 905 red_flag = True 906 size = wx.Size(850, 350) 907 tooltip = "The list model-free models to optimise as the iterative part of the protocol (see the about window for details). This really should not be changed." 908 tooltip_button = "Open the model list selector window."

909 910 911

912 -class Protocol_mode_sel_window(wx.Dialog):

913 """The protocol mode selector window object.""" 914

915 - def __init__(self):

916 """Set up the window.""" 917 918 # Set up the dialog. 919 wx.Dialog.__init__(self, None, id=-1, title="Protocol mode selection") 920 921 # Initialise some values 922 size_x = 600 923 size_y = 600 924 border = 10 925 self.select = 'Fully automated' 926 927 # Set the frame properties. 928 self.SetSize((size_x, size_y)) 929 self.Centre() 930 self.SetFont(font.normal) 931 932 # The main box sizer. 933 main_sizer = wx.BoxSizer(wx.VERTICAL) 934 935 # Pack the sizer into the frame. 936 self.SetSizer(main_sizer) 937 938 # Build the central sizer, with borders. 939 sizer = add_border(main_sizer, border=border, packing=wx.HORIZONTAL) 940 941 # Build the automatic part. 942 self.build_auto(sizer) 943 944 # Line separator. 945 sizer.Add(wx.StaticLine(self, -1, style=wx.LI_VERTICAL), 0, wx.EXPAND|wx.ALL, border) 946 947 # Build the manual part. 948 self.build_manual(sizer)

949 950

951 - def build_auto(self, sizer):

952 """Build the fully automated part of the window. 953 954 @param sizer: The sizer to pack the elements into. 955 @type sizer: wx.BoxSizer instance 956 """ 957 958 # Create a vertical sizer for the elements. 959 sub_sizer = wx.BoxSizer(wx.VERTICAL) 960 961 # The title. 962 title = wx.StaticText(self, -1, "Fully automated") 963 title.SetFont(font.subtitle) 964 sub_sizer.Add(title, 0, wx.ALIGN_CENTRE_HORIZONTAL, 0) 965 966 # Spacing. 967 sub_sizer.AddStretchSpacer() 968 969 # The button. 970 button = wx.BitmapButton(self, -1, wx.Bitmap(fetch_icon('oxygen.actions.go-bottom', "48x48"), wx.BITMAP_TYPE_ANY)) 971 button.SetMinSize((80, 80)) 972 button.SetToolTipString("Perform a fully automated analysis, looping over global models I to V and terminating with the final run. Please click on the 'About' button for more information.") 973 sub_sizer.Add(button, 3, wx.EXPAND, 0) 974 self.Bind(wx.EVT_BUTTON, self.select_full_analysis, button) 975 976 # Spacing. 977 sub_sizer.AddStretchSpacer() 978 979 # Add the sub-sizer. 980 sizer.Add(sub_sizer, 1, wx.ALL|wx.EXPAND, 0)

981 982

983 - def build_manual(self, sizer):

984 """Build the manual part of the window. 985 986 @param sizer: The sizer to pack the elements into. 987 @type sizer: wx.BoxSizer instance 988 """ 989 990 # Create a vertical sizer for the elements. 991 sub_sizer = wx.BoxSizer(wx.VERTICAL) 992 993 # The title. 994 title = wx.StaticText(self, -1, "Manual modes") 995 title.SetFont(font.subtitle) 996 sub_sizer.Add(title, 0, wx.ALIGN_CENTRE_HORIZONTAL, 0) 997 998 # Spacing. 999 sub_sizer.AddSpacer(10) 1000 1001 # The local_tm button. 1002 button = wx.Button(self, -1, "Local %s" % tm) 1003 button.SetToolTipString("Optimise global model I, the %s models. Please click on the 'About' button for more information." % local_tm) 1004 button.SetFont(font.normal) 1005 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1006 self.Bind(wx.EVT_BUTTON, self.select_local_tm, button) 1007 1008 # The sphere button. 1009 button = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, str_to_gui(" Sphere")) 1010 button.SetBitmapLabel(wx.Bitmap(IMAGE_PATH+'sphere.png', wx.BITMAP_TYPE_ANY)) 1011 button.SetFont(font.normal) 1012 button.SetToolTipString("Optimise global model II, the spherical diffusion model. Please click on the 'About' button for more information.") 1013 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1014 self.Bind(wx.EVT_BUTTON, self.select_sphere, button) 1015 1016 # The prolate spheroid button. 1017 button = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, str_to_gui(" Prolate spheroid")) 1018 button.SetBitmapLabel(wx.Bitmap(IMAGE_PATH+'prolate.png', wx.BITMAP_TYPE_ANY)) 1019 button.SetFont(font.normal) 1020 button.SetToolTipString("Optimise global model III, the prolate spheroid diffusion model. Please click on the 'About' button for more information.") 1021 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1022 self.Bind(wx.EVT_BUTTON, self.select_prolate, button) 1023 1024 # The oblate spheroid button. 1025 button = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, str_to_gui(" Oblate spheroid")) 1026 button.SetBitmapLabel(wx.Bitmap(IMAGE_PATH+'oblate.png', wx.BITMAP_TYPE_ANY)) 1027 button.SetFont(font.normal) 1028 button.SetToolTipString("Optimise global model IV, the oblate spheroid diffusion model. Please click on the 'About' button for more information.") 1029 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1030 self.Bind(wx.EVT_BUTTON, self.select_oblate, button) 1031 1032 # The ellipsoid button. 1033 button = wx.lib.buttons.ThemedGenBitmapTextButton(self, -1, None, str_to_gui(" Ellipsoid")) 1034 button.SetBitmapLabel(wx.Bitmap(IMAGE_PATH+'ellipsoid.png', wx.BITMAP_TYPE_ANY)) 1035 button.SetFont(font.normal) 1036 button.SetToolTipString("Optimise global model V, the ellipsoid diffusion model. Please click on the 'About' button for more information.") 1037 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1038 self.Bind(wx.EVT_BUTTON, self.select_ellipsoid, button) 1039 1040 # The final button. 1041 button = wx.Button(self, -1, str_to_gui("Final")) 1042 button.SetToolTipString("The final run of the protocol. Please click on the 'About' button for more information.") 1043 button.SetFont(font.normal) 1044 sub_sizer.Add(button, 1, wx.EXPAND, 0) 1045 self.Bind(wx.EVT_BUTTON, self.select_final, button) 1046 1047 # Add the sub-sizer. 1048 sizer.Add(sub_sizer, 1, wx.ALL|wx.EXPAND, 0)

1049 1050

1051 - def select_ellipsoid(self, event=None):

1052 """The ellipsoid global model has been selected. 1053 1054 @keyword event: The wx event. 1055 @type event: wx event 1056 """ 1057 1058 # Set the value. 1059 self.select = 'ellipsoid' 1060 1061 # Close the dialog. 1062 self.Close()

1063 1064

1065 - def select_final(self, event=None):

1066 """The final stage of the protocol has been selected. 1067 1068 @keyword event: The wx event. 1069 @type event: wx event 1070 """ 1071 1072 # Set the value. 1073 self.select = 'final' 1074 1075 # Close the dialog. 1076 self.Close()

1077 1078

1079 - def select_full_analysis(self, event=None):

1080 """The full analysis has been selected. 1081 1082 @keyword event: The wx event. 1083 @type event: wx event 1084 """ 1085 1086 # Set the value. 1087 self.select = 'Fully automated' 1088 1089 # Close the dialog. 1090 self.Close()

1091 1092

1093 - def select_local_tm(self, event=None):

1094 """The local_tm global model has been selected. 1095 1096 @keyword event: The wx event. 1097 @type event: wx event 1098 """ 1099 1100 # Set the value. 1101 self.select = 'local_tm' 1102 1103 # Close the dialog. 1104 self.Close()

1105 1106

1107 - def select_prolate(self, event=None):

1108 """The prolate global model has been selected. 1109 1110 @keyword event: The wx event. 1111 @type event: wx event 1112 """ 1113 1114 # Set the value. 1115 self.select = 'prolate' 1116 1117 # Close the dialog. 1118 self.Close()

1119 1120

1121 - def select_oblate(self, event=None):

1122 """The oblate global model has been selected. 1123 1124 @keyword event: The wx event. 1125 @type event: wx event 1126 """ 1127 1128 # Set the value. 1129 self.select = 'oblate' 1130 1131 # Close the dialog. 1132 self.Close()

1133 1134

1135 - def select_sphere(self, event=None):

1136 """The sphere global model has been selected. 1137 1138 @keyword event: The wx event. 1139 @type event: wx event 1140 """ 1141 1142 # Set the value. 1143 self.select = 'sphere' 1144 1145 # Close the dialog. 1146 self.Close()

1147

Source Code for Module gui.analyses.auto_model_free