source: sasview/sansview/perspectives/fitting/fitting.py @ 5e4520c

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 5e4520c was a436b2e, checked in by Jae Cho <jhjcho@…>, 13 years ago

Still working on SLDpanel

  • Property mode set to 100644
File size: 63.7 KB
Line 
1
2
3################################################################################
4#This software was developed by the University of Tennessee as part of the
5#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
6#project funded by the US National Science Foundation.
7#
8#See the license text in license.txt
9#
10#copyright 2009, University of Tennessee
11################################################################################
12
13
14import re
15import sys
16import wx
17import logging
18import numpy
19import string
20import time
21from copy import deepcopy
22import models
23import fitpage
24
25
26from DataLoader.loader import Loader
27from sans.guiframe.dataFitting import Data2D
28from sans.guiframe.dataFitting import Data1D
29from sans.guiframe.events import NewPlotEvent
30from sans.guiframe.events import StatusEvent 
31from sans.guiframe.events import EVT_SLICER_PANEL
32from sans.guiframe.events import EVT_SLICER_PARS_UPDATE
33from sans.guiframe.gui_style import GUIFRAME_ID
34from sans.guiframe.plugin_base import PluginBase
35
36from .console import ConsoleUpdate
37from .fitproblem import FitProblem
38from .fitpanel import FitPanel
39from .fit_thread import FitThread
40from .pagestate import Reader
41from .fitpage import Chi2UpdateEvent
42
43DEFAULT_BEAM = 0.005
44DEFAULT_QMIN = 0.001
45DEFAULT_QMAX = 0.13
46DEFAULT_NPTS = 50
47MAX_NBR_DATA = 4
48
49
50(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent()
51
52   
53
54class Plugin(PluginBase):
55    """
56    Fitting plugin is used to perform fit
57    """
58    def __init__(self, standalone=False):
59        PluginBase.__init__(self, name="Fitting", standalone=standalone)
60       
61        #list of panel to send to guiframe
62        self.mypanels = []
63        # reference to the current running thread
64        self.calc_2D = None
65        self.calc_1D = None
66        self.fit_thread_list = {}
67        self.residuals = None
68        self.fit_panel = None
69        # Start with a good default
70        self.elapsed = 0.022
71        # the type of optimizer selected, park or scipy
72        self.fitter  = None
73        self.fit_panel = None
74        #let fit ready
75        self.fitproblem_count = None
76        #Flag to let the plug-in know that it is running stand alone
77        self.standalone = True
78        ## dictionary of page closed and id
79        self.closed_page_dict = {}
80        ## Fit engine
81        self._fit_engine = 'scipy'
82        ## Relative error desired in the sum of squares (float); scipy only
83        self.ftol=1.49012e-08
84        #List of selected data
85        self.selected_data_list = []
86        ## list of slicer panel created to display slicer parameters and results
87        self.slicer_panels = []
88        # model 2D view
89        self.model2D_id = None
90        #keep reference of the simultaneous fit page
91        self.sim_page = None
92        self.index_model = 0
93        #Create a reader for fit page's state
94        self.state_reader = None 
95        self._extensions = '.fitv'
96        self.scipy_id = wx.NewId()
97        self.park_id = wx.NewId()
98       
99        self.temp_state = []
100        self.state_index = 0
101        self.sfile_ext = None
102        # take care of saving  data, model and page associated with each other
103        self.page_finder = {}
104        # Log startup
105        logging.info("Fitting plug-in started") 
106       
107    def populate_menu(self, owner):
108        """
109        Create a menu for the Fitting plug-in
110       
111        :param id: id to create a menu
112        :param owner: owner of menu
113       
114        :return: list of information to populate the main menu
115       
116        """
117        #Menu for fitting
118        self.menu1 = wx.Menu()
119        id1 = wx.NewId()
120        simul_help = "Add new fit panel"
121        self.menu1.Append(id1, '&New Fit Page',simul_help)
122        wx.EVT_MENU(owner, id1, self.on_add_new_page)
123        self.menu1.AppendSeparator()
124        id1 = wx.NewId()
125        simul_help = "Simultaneous Fit"
126        self.menu1.Append(id1, '&Simultaneous Fit',simul_help)
127        wx.EVT_MENU(owner, id1, self.on_add_sim_page)
128        self.menu1.AppendSeparator()
129        #Set park engine
130       
131        scipy_help= "Scipy Engine: Perform Simple fit. More in Help window...."
132        self.menu1.AppendCheckItem(self.scipy_id, "Simple Fit  [Scipy]",scipy_help) 
133        wx.EVT_MENU(owner, self.scipy_id,  self._onset_engine_scipy)
134       
135        park_help = "Park Engine: Perform Complex fit. More in Help window...."
136        self.menu1.AppendCheckItem(self.park_id, "Complex Fit  [Park]",park_help) 
137        wx.EVT_MENU(owner, self.park_id,  self._onset_engine_park)
138       
139        self.menu1.FindItemById(self.scipy_id).Check(True)
140        self.menu1.FindItemById(self.park_id).Check(False)
141        #create  menubar items
142        return [(self.menu1, self.sub_menu)]
143               
144    def on_add_sim_page(self, event):
145        """
146        Create a page to access simultaneous fit option
147        """
148        if self.sim_page != None:
149            msg= "Simultaneous Fit page already opened"
150            wx.PostEvent(self.parent, StatusEvent(status= msg))
151            return 
152       
153        self.sim_page= self.fit_panel.add_sim_page()
154       
155    def help(self, evt):
156        """
157        Show a general help dialog.
158        """
159        from help_panel import  HelpWindow
160        frame = HelpWindow(None, -1, 'HelpWindow')   
161        frame.Show(True)
162       
163    def get_context_menu(self, plotpanel=None):
164        """
165        Get the context menu items available for P(r).them allow fitting option
166        for Data2D and Data1D only.
167       
168        :param graph: the Graph object to which we attach the context menu
169       
170        :return: a list of menu items with call-back function
171       
172        :note: if Data1D was generated from Theory1D 
173                the fitting option is not allowed
174               
175        """
176        graph = plotpanel.graph
177        fit_option = "Select data for fitting"
178        fit_hint =  "Dialog with fitting parameters "
179       
180        if graph.selected_plottable not in plotpanel.plots:
181            return []
182        item = plotpanel.plots[graph.selected_plottable]
183        if item.__class__.__name__ is "Data2D": 
184            if hasattr(item,"is_data"):
185                if item.is_data:
186                    return [[fit_option, fit_hint, self._onSelect]]
187                else:
188                    return [] 
189            return [[fit_option, fit_hint, self._onSelect]]
190        else:
191           
192            # if is_data is true , this in an actual data loaded
193            #else it is a data created from a theory model
194            if hasattr(item,"is_data"):
195                if item.is_data:
196                    return [[fit_option, fit_hint,
197                              self._onSelect]]
198                else:
199                    return [] 
200        return []   
201
202
203    def get_panels(self, parent):
204        """
205        Create and return a list of panel objects
206        """
207        self.parent = parent
208        #self.parent.Bind(EVT_FITSTATE_UPDATE, self.on_set_state_helper)
209        # Creation of the fit panel
210        self.fit_panel = FitPanel(parent=self.parent, manager=self)
211        self.on_add_new_page(event=None)
212        #Set the manager for the main panel
213        self.fit_panel.set_manager(self)
214        # List of windows used for the perspective
215        self.perspective = []
216        self.perspective.append(self.fit_panel.window_name)
217       
218        #index number to create random model name
219        self.index_model = 0
220        self.index_theory= 0
221        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
222        self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
223        self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer)   
224        #Create reader when fitting panel are created
225        self.state_reader = Reader(self.set_state)   
226        #append that reader to list of available reader
227        loader = Loader()
228        loader.associate_file_reader(".fitv", self.state_reader)
229        #loader.associate_file_reader(".svs", self.state_reader)
230        #from sans.perspectives.calculator.sld_panel import SldPanel
231        #Send the fitting panel to guiframe
232        self.mypanels.append(self.fit_panel) 
233        #self.mypanels.append(SldPanel(parent=self.parent, base=self.parent))
234        return self.mypanels
235   
236    def clear_panel(self):
237        """
238        """
239        self.fit_panel.clear_panel()
240       
241    def set_default_perspective(self):
242        """
243        Call back method that True to notify the parent that the current plug-in
244        can be set as default  perspective.
245        when returning False, the plug-in is not candidate for an automatic
246        default perspective setting
247        """
248        return True
249   
250    def delete_data(self, data):
251        """
252        delete  the given data from panel
253        """
254        self.fit_panel.delete_data(data)
255       
256    def set_data(self, data_list=None):
257        """
258        receive a list of data to fit
259        """
260        if data_list is None:
261            data_list = []
262        selected_data_list = []
263        if len(data_list) > MAX_NBR_DATA :
264            from fitting_widgets import DataDialog
265            dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
266            if dlg.ShowModal() == wx.ID_OK:
267                selected_data_list = dlg.get_data()
268            dlg.Destroy()
269           
270        else:
271            selected_data_list = data_list
272        try:
273            for data in selected_data_list:
274                self.add_fit_page(data=data)
275                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
276                                                       title=str(data.title)))
277               
278        except:
279            raise
280            #msg = "Fitting Set_data: " + str(sys.exc_value)
281            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
282   
283    def set_top_panel(self):
284        """
285        Close default (welcome) panel
286        """
287        if 'default' in self.parent.panels:
288            self.parent.on_close_welcome_panel()
289
290             
291    def set_theory(self,  theory_list=None):
292        """
293        """
294        #set the model state for a given theory_state:
295        for item in theory_list:
296            try:
297                _, theory_state = item
298                self.fit_panel.set_model_state(theory_state)
299            except:
300                msg = "Fitting: cannot deal with the theory received"
301                logging.error("set_theory " + msg + "\n" + str(sys.exc_value))
302                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
303           
304    def set_state(self, state=None, datainfo=None, format=None):
305        """
306        Call-back method for the fit page state reader.
307        This method is called when a .fitv/.svs file is loaded.
308       
309        : param state: PageState object
310        : param datainfo: data
311        """
312        #state = self.state_reader.get_state()
313        if state != None:
314            state = state.clone()
315            # store fitting state in temp_state
316            self.temp_state.append(state) 
317        else:
318            self.temp_state = []
319        # index to start with for a new set_state
320        self.state_index = 0
321        # state file format
322        self.sfile_ext = format
323       
324        self.on_set_state_helper(event=None)
325
326    def  on_set_state_helper(self,event=None):
327        """
328        Set_state_helper. This actually sets state after plotting data from state file.
329       
330        : event: FitStateUpdateEvent called by dataloader.plot_data from guiframe
331        """
332        if len(self.temp_state) == 0:
333            if self.state_index==0 and len(self.mypanels) <= 0 and self.sfile_ext =='.svs':
334                self.fit_panel.add_default_pages()
335                self.temp_state = []
336                self.state_index = 0
337            return
338       
339        try:
340            # Load fitting state
341            state = self.temp_state[self.state_index]
342            #panel state should have model selection to set_state
343            if state.formfactorcombobox != None:
344                #set state
345                data = self.parent.create_gui_data(state.data)
346                data.group_id = state.data.group_id
347                self.parent.add_data(data_list={data.id:data})
348                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
349                                        title=data.title))
350                #need to be fix later make sure we are sendind guiframe.data
351                #to panel
352                state.data = data
353                page = self.fit_panel.set_state(state)   
354            else:
355                #just set data because set_state won't work
356                data = self.parent.create_gui_data(state.data)
357                data.group_id = state.data.group_id
358                self.parent.add_data(data_list={data.id:data})
359                wx.PostEvent(self.parent, NewPlotEvent(plot=data,
360                                        title=data.title))
361                page = self.add_fit_page(data)
362                caption = page.window_name
363                self.store_data(page=page.id, data=data, caption=caption)
364                self.mypanels.append(page) 
365               
366            # get ready for the next set_state
367            self.state_index += 1
368
369            #reset state variables to default when all set_state is finished.
370            if len(self.temp_state) == self.state_index:
371               
372                self.temp_state = []
373                #self.state_index = 0
374                # Make sure the user sees the fitting panel after loading
375                #self.parent.set_perspective(self.perspective)
376                self.on_perspective(event=None)
377        except:
378            self.state_index==0
379            self.temp_state = []
380            raise
381                 
382    def save_fit_state(self, filepath, fitstate): 
383        """
384        save fit page state into file
385        """
386        self.state_reader.write(filename=filepath, fitstate=fitstate)
387       
388    def set_fit_range(self, uid, qmin, qmax):
389        """
390        Set the fitting range of a given page
391        """
392        self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
393                   
394    def schedule_for_fit(self,value=0, uid=None,fitproblem =None): 
395        """
396        Set the fit problem field to 0 or 1 to schedule that problem to fit.
397        Schedule the specified fitproblem or get the fit problem related to
398        the current page and set value.
399       
400        :param value: integer 0 or 1
401        :param fitproblem: fitproblem to schedule or not to fit
402       
403        """   
404        if fitproblem !=None:
405            fitproblem.schedule_tofit(value)
406        else:
407            self.page_finder[uid].schedule_tofit(value)
408         
409    def get_page_finder(self):
410        """
411        return self.page_finder used also by simfitpage.py
412        """ 
413        return self.page_finder
414   
415    def set_page_finder(self,modelname,names,values):
416        """
417        Used by simfitpage.py to reset a parameter given the string constrainst.
418         
419        :param modelname: the name ot the model for with the parameter has to reset
420        :param value: can be a string in this case.
421        :param names: the paramter name
422         
423        :note: expecting park used for fit.
424         
425        """ 
426        sim_page_id = self.sim_page.uid
427        for uid, value in self.page_finder.iteritems():
428            if uid != sim_page_id:
429                list = value.get_model()
430                model = list[0]
431                if model.name == modelname:
432                    value.set_model_param(names, values)
433                    break
434         
435    def split_string(self,item): 
436        """
437        receive a word containing dot and split it. used to split parameterset
438        name into model name and parameter name example: ::
439       
440            paramaterset (item) = M1.A
441            Will return model_name = M1 , parameter name = A
442           
443        """
444        if string.find(item,".")!=-1:
445            param_names= re.split("\.",item)
446            model_name=param_names[0]           
447            ##Assume max len is 3; eg., M0.radius.width
448            if len(param_names) == 3:
449                param_name=param_names[1]+"."+param_names[2]
450            else:
451                param_name=param_names[1]                   
452            return model_name,param_name
453   
454    def set_ftol(self, ftol=None):
455        """
456        Set ftol: Relative error desired in the sum of chi squares. 
457        """
458        # check if it is flaot
459        try:
460            f_tol = float(ftol)
461        except:
462            # default
463            f_tol = 1.49012e-08
464           
465        self.ftol = f_tol
466             
467    def stop_fit(self, uid):
468        """
469        Stop the fit engine
470        """
471        if uid in self.fit_thread_list.keys():
472            calc_fit = self.fit_thread_list[uid]
473            if calc_fit is not  None and calc_fit.isrunning():
474                calc_fit.stop()
475                msg = "Fit stop!"
476                wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
477        #set the fit button label of page when fit stop is trigger from
478        #simultaneous fit pane
479        if  self.sim_page is not None and uid == self.sim_page.uid:
480            for uid, value in self.page_finder.iteritems():
481                if value.get_scheduled() == 1:
482                    if uid in self.fit_panel.opened_pages.keys():
483                        panel = self.fit_panel.opened_pages[uid]
484                        panel. _on_fit_complete()
485 
486    def set_smearer(self, uid, smearer, qmin=None, qmax=None, draw=True, 
487                    enable2D=False):
488        """
489        Get a smear object and store it to a fit problem
490       
491        :param smearer: smear object to allow smearing data
492       
493        """   
494        if uid not in self.page_finder.keys():
495            msg = "Cannot find ID: %s in page_finder" % str(uid)
496            raise ValueError, msg
497        self.page_finder[uid].set_smearer(smearer)
498        self.page_finder[uid].set_enable2D(enable2D)
499        if draw:
500            ## draw model 1D with smeared data
501            data =  self.page_finder[uid].get_fit_data()
502            model = self.page_finder[uid].get_model()
503            if model is None:
504                return
505            enable1D = True
506            enable2D = self.page_finder[uid].get_enable2D()
507            if enable2D:
508                enable1D = False
509
510            ## if user has already selected a model to plot
511            ## redraw the model with data smeared
512            smear = self.page_finder[uid].get_smearer()
513            self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
514                enable1D=enable1D, enable2D=enable2D,
515                qmin=qmin, qmax=qmax)
516
517    def draw_model(self, model, page_id, data=None, smearer=None,
518                   enable1D=True, enable2D=False,
519                   state=None,
520                   toggle_mode_on=False,
521                   qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, 
522                   qstep=DEFAULT_NPTS,
523                   update_chisqr=True):
524        """
525        Draw model.
526       
527        :param model: the model to draw
528        :param name: the name of the model to draw
529        :param data: the data on which the model is based to be drawn
530        :param description: model's description
531        :param enable1D: if true enable drawing model 1D
532        :param enable2D: if true enable drawing model 2D
533        :param qmin:  Range's minimum value to draw model
534        :param qmax:  Range's maximum value to draw model
535        :param qstep: number of step to divide the x and y-axis
536        :param update_chisqr: update chisqr [bool]
537             
538        """
539        if data.__class__.__name__ == "Data1D" or not enable2D:   
540            ## draw model 1D with no loaded data
541            self._draw_model1D(model=model, 
542                               data=data,
543                               page_id=page_id,
544                               enable1D=enable1D, 
545                               smearer=smearer,
546                               qmin=qmin,
547                               qmax=qmax, 
548                               toggle_mode_on=toggle_mode_on,
549                               state=state,
550                               qstep=qstep,
551                               update_chisqr=update_chisqr)
552        else:     
553            ## draw model 2D with no initial data
554            self._draw_model2D(model=model,
555                                page_id=page_id,
556                                data=data,
557                                enable2D=enable2D,
558                                smearer=smearer,
559                                qmin=qmin,
560                                qmax=qmax,
561                                state=state,
562                                toggle_mode_on=toggle_mode_on,
563                                qstep=qstep,
564                                update_chisqr=update_chisqr)
565           
566    def onFit(self):
567        """
568        perform fit
569        """
570        ##  count the number of fitproblem schedule to fit
571        fitproblem_count = 0
572        for value in self.page_finder.values():
573            if value.get_scheduled() == 1:
574                fitproblem_count += 1
575               
576        ## if simultaneous fit change automatically the engine to park
577        if fitproblem_count > 1:
578            self._on_change_engine(engine='park')
579           
580        self.fitproblem_count = fitproblem_count 
581         
582        from sans.fit.Fitting import Fit
583        fitter = Fit(self._fit_engine)
584       
585        if self._fit_engine == "park":
586            engineType = "Simultaneous Fit"
587        else:
588            engineType = "Single Fit"
589           
590        fproblemId = 0
591        self.current_pg = None
592        list_page_id = []
593        for page_id, value in self.page_finder.iteritems():
594            try:
595                if value.get_scheduled() == 1:
596                    #Get list of parameters name to fit
597                    pars = []
598                    templist = []
599                   
600                    page = self.fit_panel.get_page_by_id(page_id)
601                    templist = page.get_param_list()
602                    # missing fit parameters
603                    #if not templist:
604                    #    return
605                    # have the list
606                    for element in templist:
607                        name = str(element[1])
608                        pars.append(name)
609                    #Set Engine  (model , data) related to the page on
610                    self._fit_helper(value=value, pars=pars,
611                                     fitter=fitter,
612                                      fitproblem_id=fproblemId,
613                                      title=engineType) 
614                    list_page_id.append(page_id)
615                    fproblemId += 1 
616                    current_page_id = page_id
617            except:
618                #raise
619                msg= "%s error: %s" % (engineType, sys.exc_value)
620                wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
621                                                      type="stop"))
622                return 
623        ## If a thread is already started, stop it
624        #if self.calc_fit!= None and self.calc_fit.isrunning():
625        #    self.calc_fit.stop()
626         #Handler used for park engine displayed message
627        handler = ConsoleUpdate(parent=self.parent,
628                                manager=self,
629                                improvement_delta=0.1)
630       
631        ## perform single fit
632        if fitproblem_count == 1:
633            calc_fit = FitThread(handler = handler,
634                                    fn=fitter,
635                                    pars=pars,
636                                    page_id=list_page_id,
637                                    completefn=self._single_fit_completed,
638                                    ftol=self.ftol)
639        else:
640            current_page_id = self.sim_page.uid
641            ## Perform more than 1 fit at the time
642            calc_fit = FitThread(handler=handler,
643                                    fn=fitter,
644                                    page_id=list_page_id,
645                                    updatefn=handler.update_fit,
646                                    completefn=self._simul_fit_completed,
647                                    ftol=self.ftol)
648        self.fit_thread_list[current_page_id] = calc_fit
649        calc_fit.queue()
650        msg = "Fitting is in progress..."
651        wx.PostEvent( self.parent, StatusEvent(status=msg, type="progress" ))
652       
653        self.ready_fit(calc_fit=calc_fit)
654     
655           
656    def ready_fit(self, calc_fit):
657        """
658        Ready for another fit
659        """
660        if self.fitproblem_count != None and self.fitproblem_count > 1:
661            calc_fit.ready(2.5)
662           
663        else:
664            time.sleep(0.4)
665           
666    def remove_plot(self, uid, theory=False):
667        """
668        remove model plot when a fit page is closed
669        """
670        fitproblem = self.page_finder[uid]
671        data = fitproblem.get_fit_data()
672        model = fitproblem.get_model()
673        plot_id = None
674        if model is not None:
675            plot_id = data.id + name
676        if theory:
677            plot_id = data.id
678        group_id = data.group_id
679        wx.PostEvent(self.parent, NewPlotEvent(id=plot_id,
680                                                   group_id=group_id,
681                                                   action='remove'))
682           
683    def store_data(self, uid, data=None, caption=None):
684        """
685        Helper to save page reference into the plug-in
686       
687        :param page: page to store
688       
689        """
690        #create a fitproblem storing all link to data,model,page creation
691        if not uid in self.page_finder.keys():
692            self.page_finder[uid] = FitProblem()
693        self.page_finder[uid].set_fit_data(data)
694        self.page_finder[uid].set_fit_tab_caption(caption)
695       
696    def on_add_new_page(self, event=None):
697        """
698        ask fit panel to create a new empty page
699        """
700        try:
701            page = self.fit_panel.add_empty_page()
702            page_caption = page.window_name
703            # add data associated to the page created
704            if page != None: 
705                self.store_data(uid=page.uid, caption=page_caption,
706                                data=page.get_data())
707                wx.PostEvent(self.parent, StatusEvent(status="Page Created",
708                                               info="info"))
709            else:
710                msg = "Page was already Created"
711                wx.PostEvent(self.parent, StatusEvent(status=msg,
712                                                       info="warning"))
713            self.set_top_panel()
714        except:
715            raise
716            #msg = "Creating Fit page: %s"%sys.exc_value
717            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
718       
719       
720    def add_fit_page(self, data):
721        """
722        given a data, ask to the fitting panel to create a new fitting page,
723        get this page and store it into the page_finder of this plug-in
724        """
725        page = self.fit_panel.set_data(data)
726        page_caption = page.window_name
727        #append Data1D to the panel containing its theory
728        #if theory already plotted
729        if page.uid in self.page_finder:
730            theory_data = self.page_finder[page.uid].get_theory_data()
731            if issubclass(data.__class__, Data2D):
732                data.group_id = wx.NewId()
733                if theory_data is not None:
734                    group_id = str(page.uid) + " Model1D"
735                    wx.PostEvent(self.parent, 
736                             NewPlotEvent(group_id=group_id,
737                                               action="delete"))
738                    self.parent.update_data(prev_data=theory_data, new_data=data)     
739            else:
740                if theory_data is not None:
741                    group_id = str(page.uid) + " Model2D"
742                    data.group_id = theory_data.group_id
743                    wx.PostEvent(self.parent, 
744                             NewPlotEvent(group_id=group_id,
745                                               action="delete"))
746                    self.parent.update_data(prev_data=theory_data, new_data=data)   
747             
748        self.store_data(uid=page.uid, data=data, caption=page.window_name)
749        if self.sim_page is not None:
750            self.sim_page.draw_page()
751        return page
752           
753    def _onEVT_SLICER_PANEL(self, event):
754        """
755        receive and event telling to update a panel with a name starting with
756        event.panel_name. this method update slicer panel for a given interactor.
757       
758        :param event: contains type of slicer , paramaters for updating the panel
759            and panel_name to find the slicer 's panel concerned.
760        """
761        for item in self.parent.panels:
762            if self.parent.panels[item].window_caption.startswith(event.panel_name):
763                self.parent.panels[item].set_slicer(event.type, event.params)
764               
765        self.parent._mgr.Update()
766   
767    def _closed_fitpage(self, event):   
768        """
769        request fitpanel to close a given page when its unique data is removed
770        from the plot. close fitpage only when the a loaded data is removed
771        """   
772        if event is None or event.data is None:
773            return
774        if hasattr(event.data,"is_data"):
775            if not event.data.is_data or \
776                event.data.__class__.__name__ == "Data1D":
777                self.fit_panel.close_page_with_data(event.data) 
778       
779    def _add_page_onmenu(self, name, fitproblem=None):
780        """
781        Add name of a closed page of fitpanel in a menu
782        """
783        list = self.menu1.GetMenuItems()
784        for item in list:
785            if name == item.GetItemLabel():
786                self.closed_page_dict[name][1] = fitproblem
787               
788        if not name in self.closed_page_dict.keys():   
789            # Post paramters
790            event_id = wx.NewId()
791            self.menu1.Append(event_id, name, "Show %s fit panel" % name)
792            self.closed_page_dict[name]= [event_id, fitproblem]
793            wx.EVT_MENU(self.parent, event_id, self._open_closed_page)
794       
795    def _open_closed_page(self, event):   
796        """
797        reopen a closed page
798        """
799        for name, value in self.closed_page_dict.iteritems():
800            if event.GetId() in value:
801                uid,fitproblem = value
802                if name !="Model":
803                    data= fitproblem.get_fit_data()
804                    page = self.fit_panel.add_fit_page(data=data, reset=True)
805                    if fitproblem != None:
806                        self.page_finder[uid] = fitproblem
807                        if self.sim_page != None:
808                            self.sim_page.draw_page()
809                           
810                else:
811                    model = fitproblem
812                    self.fit_panel.add_model_page(model=model, topmenu=True,
813                                                  reset= True)
814                    break
815   
816    def _reset_schedule_problem(self, value=0):
817        """
818        unschedule or schedule all fitproblem to be fit
819        """
820        for page_id in self.page_finder.keys():
821            self.page_finder[page_id].schedule_tofit(value)
822           
823    def _fit_helper(self, pars, value, fitproblem_id,fitter, title="Single Fit " ):
824        """
825        helper for fitting
826        """
827        metadata = value.get_fit_data()
828        model = value.get_model()
829        smearer = value.get_smearer()
830        qmin, qmax = value.get_range()
831        self.fit_id = fitproblem_id
832        #Create list of parameters for fitting used
833        templist = []
834       
835        try:
836            #Extra list of parameters and their constraints
837            listOfConstraint = []
838           
839            param = value.get_model_param()
840            if len(param) > 0:
841                for item in param:
842                    ## check if constraint
843                    if item[0] != None and item[1] != None:
844                        listOfConstraint.append((item[0],item[1]))
845                   
846            #Do the single fit
847            fitter.set_model(model, self.fit_id,
848                                   pars, constraints=listOfConstraint)
849           
850            fitter.set_data(data=metadata, id=self.fit_id,
851                                 smearer=smearer, qmin=qmin, qmax=qmax)
852           
853            fitter.select_problem_for_fit(id=self.fit_id,
854                                               value=value.get_scheduled())
855            value.clear_model_param()
856        except:
857            raise
858            #msg = title + " error: %s" % sys.exc_value
859            #wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
860         
861    def _onSelect(self,event):
862        """
863        when Select data to fit a new page is created .Its reference is
864        added to self.page_finder
865        """
866        self.panel = event.GetEventObject()
867        Plugin.on_perspective(self, event=event)
868        for plottable in self.panel.graph.plottables:
869            if plottable.__class__.__name__ in ["Data1D", "Theory1D"]:
870                data_id = self.panel.graph.selected_plottable
871                if plottable == self.panel.plots[data_id]:
872                    data = plottable
873                    self.add_fit_page(data=data)
874                    return
875            else:
876                data = plottable
877                self.add_fit_page(data=data)
878        self.set_top_panel()
879           
880    def update_fit(self, result=None, msg=""):
881        """
882        """
883        print "update_fit result", result
884       
885    def _single_fit_completed(self, result, pars, page_id, elapsed=None):
886        """
887        Display fit result on one page of the notebook.
888       
889        :param result: result of fit
890        :param pars: list of names of parameters fitted
891        :param current_pg: the page where information will be displayed
892        :param qmin: the minimum value of x to replot the model
893        :param qmax: the maximum value of x to replot model
894         
895        """     
896        try:
897            if result == None:
898                msg= "Single Fitting did not converge!!!"
899                wx.PostEvent(self.parent, 
900                             StatusEvent(status=msg, 
901                                         info="warning",
902                                         type="stop"))
903                return
904            if not numpy.isfinite(result.fitness) or \
905                    numpy.any(result.pvec == None) or \
906                    not numpy.all(numpy.isfinite(result.pvec)):
907                msg = "Single Fitting did not converge!!!"
908                wx.PostEvent(self.parent, 
909                             StatusEvent(status=msg, 
910                                         info="warning",
911                                         type="stop"))
912                return
913            for uid in page_id:
914                value = self.page_finder[uid]   
915                model = value.get_model()
916                page_id = uid
917                   
918                param_name = []
919                for name in pars:
920                    param_name.append(name)
921                   
922                cpage = self.fit_panel.get_page_by_id(uid)
923                cpage.onsetValues(result.fitness, 
924                                  param_name, result.pvec,result.stderr)
925                cpage._on_fit_complete()
926
927        except ValueError:
928            msg = "Single Fitting did not converge!!!"
929            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
930                                                  type="stop"))
931            return   
932        except:
933            raise
934            #msg = "Single Fit completed but Following"
935            #msg += " error occurred:%s" % sys.exc_value
936            #wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
937            #                                      type="stop"))
938            return
939       
940    def _simul_fit_completed(self, result, page_id,pars=None, elapsed=None):
941        """
942        Parameter estimation completed,
943        display the results to the user
944       
945        :param alpha: estimated best alpha
946        :param elapsed: computation time
947       
948        """
949        if page_id is None:
950            page_id = []
951        ## fit more than 1 model at the same time
952        try:
953            msg = "" 
954            if result == None:
955                msg= "Complex Fitting did not converge!!!"
956                wx.PostEvent(self.parent, StatusEvent(status=msg,
957                                                      type="stop"))
958                return
959            if not numpy.isfinite(result.fitness) or \
960                numpy.any(result.pvec == None) or not \
961                numpy.all(numpy.isfinite(result.pvec)):
962                msg= "Simultaneous Fitting did not converge!!!"
963                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
964                return
965             
966            for uid in page_id:   
967                value = self.page_finder[uid]
968                model = value.get_model()
969                data =  value.get_fit_data()
970                small_param_name = []
971                small_out = []
972                small_cov = []
973                #Separate result in to data corresponding to each page
974                for p in result.parameters:
975                    model_name, param_name = self.split_string(p.name) 
976                    if model.name == model_name:
977                        p_name= model.name+"."+param_name
978                        if p.name == p_name:     
979                            if p.value != None and numpy.isfinite(p.value):
980                                small_out.append(p.value)
981                                small_param_name.append(param_name)
982                                small_cov.append(p.stderr)
983                # Display result on each page
984                cpage = self.fit_panel.get_page_by_id(uid)
985                cpage.onsetValues(result.fitness,
986                                  small_param_name,
987                                  small_out,small_cov)
988                cpage._on_fit_complete()
989               
990        except Exception:
991            msg = "Complex Fitting did not converge!!!"
992            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
993                                                  type="stop"))
994            return
995
996        except:
997            msg = "Simultaneous Fit completed"
998            msg += " but Following error occurred:%s" % sys.exc_value
999            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
1000   
1001    def _on_show_panel(self, event):
1002        """
1003        """
1004        pass
1005       
1006    def _onset_engine_park(self,event):
1007        """
1008        set engine to park
1009        """
1010        self._on_change_engine('park')
1011       
1012    def _onset_engine_scipy(self,event):
1013        """
1014        set engine to scipy
1015        """
1016        self._on_change_engine('scipy')
1017       
1018    def _on_slicer_event(self, event):
1019        """
1020        Receive a panel as event and send it to guiframe
1021       
1022        :param event: event containing a panel
1023       
1024        """
1025        if event.panel is not None:
1026            new_panel = event.panel
1027            self.slicer_panels.append(event.panel)
1028            # Set group ID if available
1029            event_id = self.parent.popup_panel(new_panel)
1030            #self.menu3.Append(event_id, new_panel.window_caption,
1031            #                 "Show %s plot panel" % new_panel.window_caption)
1032            # Set id to allow us to reference the panel later
1033         
1034            new_panel.uid = event_id
1035            self.mypanels.append(new_panel) 
1036       
1037    def _onclearslicer(self, event):
1038        """
1039        Clear the boxslicer when close the panel associate with this slicer
1040        """
1041        name =event.GetPane().caption
1042   
1043        for panel in self.slicer_panels:
1044            if panel.window_caption==name:
1045               
1046                for item in self.parent.panels:
1047                    if hasattr(self.parent.panels[item],"uid"):
1048                        if self.parent.panels[item].uid ==panel.base.uid:
1049                            self.parent.panels[item].onClearSlicer(event)
1050                            self.parent._mgr.Update()
1051                            break 
1052                break
1053   
1054    def _return_engine_type(self):
1055        """
1056        return the current type of engine
1057        """
1058        return self._fit_engine
1059     
1060     
1061    def _on_change_engine(self, engine='park'):
1062        """
1063        Allow to select the type of engine to perform fit
1064       
1065        :param engine: the key work of the engine
1066       
1067        """
1068        ## saving fit engine name
1069        self._fit_engine = engine
1070        ## change menu item state
1071        if engine=="park":
1072            self.menu1.FindItemById(self.park_id).Check(True)
1073            self.menu1.FindItemById(self.scipy_id).Check(False)
1074        else:
1075            self.menu1.FindItemById(self.park_id).Check(False)
1076            self.menu1.FindItemById(self.scipy_id).Check(True)
1077        ## post a message to status bar
1078        msg = "Engine set to: %s" % self._fit_engine
1079        wx.PostEvent(self.parent, 
1080                     StatusEvent(status=msg))
1081        ## send the current engine type to fitpanel
1082        self.fit_panel._on_engine_change(name=self._fit_engine)
1083       
1084    def _on_model_panel(self, evt):
1085        """
1086        react to model selection on any combo box or model menu.plot the model 
1087       
1088        :param evt: wx.combobox event
1089       
1090        """
1091        model = evt.model
1092        uid = evt.uid
1093        qmin = evt.qmin
1094        qmax = evt.qmax
1095        smearer = evt.smearer
1096       
1097        if model == None:
1098            return
1099
1100        if self.page_finder[uid].get_model() is None:
1101            model.name = "M" + str(self.index_model)
1102            self.index_model += 1 
1103        else:
1104            model.name = self.page_finder[uid].get_model().name
1105        # save the name containing the data name with the appropriate model
1106        self.page_finder[uid].set_model(model)
1107        self.page_finder[uid].set_range(qmin=qmin, qmax=qmax)
1108        if self.sim_page is not None:
1109            self.sim_page.draw_page()
1110       
1111    def _update1D(self,x, output):
1112        """
1113        Update the output of plotting model 1D
1114        """
1115        msg = "Plot updating ... "
1116        wx.PostEvent(self.parent, StatusEvent(status=msg,type="update"))
1117        self.ready_fit()
1118       
1119   
1120    def _fill_default_model2D(self, theory, page_id, qmax,qstep, qmin=None):
1121        """
1122        fill Data2D with default value
1123       
1124        :param theory: Data2D to fill
1125       
1126        """
1127        from DataLoader.data_info import Detector, Source
1128       
1129        detector = Detector()
1130        theory.detector.append(detector)         
1131        theory.source= Source()
1132       
1133        ## Default values   
1134        theory.detector[0].distance= 8000   # mm       
1135        theory.source.wavelength= 6         # A     
1136        theory.detector[0].pixel_size.x= 5  # mm
1137        theory.detector[0].pixel_size.y= 5  # mm
1138       
1139        theory.detector[0].beam_center.x= qmax
1140        theory.detector[0].beam_center.y= qmax
1141   
1142        ## create x_bins and y_bins of the model 2D
1143        pixel_width_x = theory.detector[0].pixel_size.x
1144        pixel_width_y = theory.detector[0].pixel_size.y
1145        center_x      = theory.detector[0].beam_center.x/pixel_width_x
1146        center_y      = theory.detector[0].beam_center.y/pixel_width_y
1147
1148        # theory default: assume the beam
1149        #center is located at the center of sqr detector
1150        xmax = qmax
1151        xmin = -qmax
1152        ymax = qmax
1153        ymin = -qmax
1154       
1155        x=  numpy.linspace(start= -1*qmax,
1156                               stop=qmax,
1157                               num=qstep,
1158                               endpoint=True) 
1159        y = numpy.linspace(start=-1*qmax,
1160                               stop= qmax,
1161                               num= qstep,
1162                               endpoint=True)
1163         
1164        ## use data info instead
1165        new_x = numpy.tile(x, (len(y),1))
1166        new_y = numpy.tile(y, (len(x),1))
1167        new_y = new_y.swapaxes(0,1)
1168       
1169        # all data reuire now in 1d array
1170        qx_data = new_x.flatten()
1171        qy_data = new_y.flatten()
1172       
1173        q_data = numpy.sqrt(qx_data*qx_data+qy_data*qy_data)
1174        # set all True (standing for unmasked) as default
1175        mask    = numpy.ones(len(qx_data), dtype = bool)
1176       
1177        # calculate the range of qx and qy: this way,
1178        # it is a little more independent
1179        x_size = xmax- xmin
1180        y_size = ymax -ymin
1181       
1182        # store x and y bin centers in q space
1183        x_bins  = x
1184        y_bins  = y
1185        # bin size: x- & y-directions
1186        xstep = x_size/len(x_bins-1)
1187        ystep = y_size/len(y_bins-1)
1188       
1189        #theory.data = numpy.zeros(len(mask))
1190        theory.err_data = numpy.ones(len(mask))
1191        theory.qx_data = qx_data
1192        theory.qy_data = qy_data 
1193        theory.q_data = q_data
1194        theory.mask = mask           
1195        theory.x_bins = x_bins 
1196        theory.y_bins = y_bins   
1197       
1198        # max and min taking account of the bin sizes
1199        theory.xmin = xmin
1200        theory.xmax = xmax
1201        theory.ymin = ymin
1202        theory.ymax = ymax
1203        theory.group_id = str(page_id) + " Model2D"
1204        theory.id = str(page_id) + " Model2D"
1205 
1206    def _complete1D(self, x,y, page_id, elapsed,index,model,
1207                    toggle_mode_on=False,state=None, 
1208                    data=None, update_chisqr=True):
1209        """
1210        Complete plotting 1D data
1211        """ 
1212        try:
1213            new_plot = Data1D(x=x, y=y)
1214            new_plot.is_data = False
1215            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM
1216            if data != None:
1217                _xaxis, _xunit = data.get_xaxis() 
1218                _yaxis, _yunit = data.get_yaxis() 
1219                new_plot.title = data.name
1220                #if the theory is already plotted use the same group id
1221                #to replot
1222                if page_id in self.page_finder:
1223                    theory_data = self.page_finder[page_id].get_theory_data()
1224                    if theory_data is not None:
1225                       data.group_id = theory_data.group_id
1226                #data is plotted before the theory, then take its group_id
1227                #assign to the new theory
1228                new_plot.group_id = data.group_id
1229               
1230            else:
1231                _xaxis, _xunit = "\\rm{Q}", 'A^{-1}'
1232                _yaxis, _yunit = "\\rm{Intensity} ", "cm^{-1}"
1233                new_plot.title = "Analytical model 1D "
1234                #find a group id to plot theory without data
1235                new_plot.group_id =  str(page_id) + " Model1D" 
1236            new_plot.id =  str(page_id) + " Model1D" 
1237           
1238            #find if this theory was already plotted and replace that plot given
1239            #the same id
1240           
1241            theory_data = self.page_finder[page_id].get_theory_data()
1242            if theory_data is not None:
1243                new_plot.id = theory_data.id
1244             
1245            new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]"
1246            new_plot.xaxis(_xaxis, _xunit)
1247            new_plot.yaxis(_yaxis, _yunit)
1248            if toggle_mode_on:
1249                new_plot.id =  str(page_id) + " Model" 
1250                wx.PostEvent(self.parent, 
1251                             NewPlotEvent(group_id=str(page_id) + " Model2D",
1252                                               action="Hide"))
1253           
1254            self.page_finder[page_id].set_theory_data(new_plot)
1255            if data is None:
1256                data_id = None
1257            else:
1258                data_id = data.id
1259            self.parent.update_theory(data_id=data_id, 
1260                                       theory=new_plot,
1261                                       state=state)     
1262            current_pg = self.fit_panel.get_page_by_id(page_id)
1263            title = new_plot.title
1264            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1265                                            title= str(title)))
1266           
1267            self.page_finder[page_id].set_theory_data(new_plot)
1268           
1269            if update_chisqr:
1270                wx.PostEvent(current_pg,
1271                             Chi2UpdateEvent(output=self._cal_chisqr(data=data,
1272                                                        page_id=page_id,
1273                                                        index=index)))
1274            else:
1275                self._plot_residuals(page_id, data, index)
1276
1277            msg = "Plot 1D  complete !"
1278            wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" ))
1279            #self.current_pg.state.theory_data = deepcopy(self.theory_data)
1280        except:
1281            raise
1282            #msg = " Error occurred when drawing %s Model 1D: " % new_plot.name
1283            #msg += " %s"  % sys.exc_value
1284            #wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
1285   
1286    def _update2D(self, output,time=None):
1287        """
1288        Update the output of plotting model
1289        """
1290        wx.PostEvent(self.parent, StatusEvent(status="Plot \
1291        #updating ... ", type="update"))
1292        self.ready_fit()
1293 
1294    def _complete2D(self, image, data, model, page_id,  elapsed, index, qmin,
1295                     qmax, toggle_mode_on=False,state=None,qstep=DEFAULT_NPTS, 
1296                     update_chisqr=True):
1297        """
1298        Complete get the result of modelthread and create model 2D
1299        that can be plot.
1300        """
1301        err_image = numpy.zeros(numpy.shape(image))
1302       
1303        new_plot= Data2D(image=image, err_image=err_image)
1304        new_plot.name = model.name
1305        new_plot.title = "Analytical model 2D "
1306        if data is None:
1307            self._fill_default_model2D(theory=new_plot, 
1308                                       qmax=qmax, 
1309                                       page_id=page_id,
1310                                       qstep=qstep,
1311                                        qmin= qmin)
1312           
1313        else:
1314            new_plot.id = str(page_id) + " Model2D"
1315            new_plot.group_id = str(page_id) + " Model2D"
1316            new_plot.x_bins = data.x_bins
1317            new_plot.y_bins = data.y_bins
1318            new_plot.detector = data.detector
1319            new_plot.source = data.source
1320            new_plot.is_data = False 
1321            new_plot.qx_data = data.qx_data
1322            new_plot.qy_data = data.qy_data
1323            new_plot.q_data = data.q_data
1324            #numpy.zeros(len(data.err_data))#data.err_data
1325            new_plot.err_data = err_image
1326            new_plot.mask = data.mask
1327            ## plot boundaries
1328            new_plot.ymin = data.ymin
1329            new_plot.ymax = data.ymax
1330            new_plot.xmin = data.xmin
1331            new_plot.xmax = data.xmax
1332            title = data.title
1333            if len(title) > 1:
1334                new_plot.title = "Model2D for " + data.name
1335        new_plot.is_data = False
1336        new_plot.name = model.name + " ["+ str(model.__class__.__name__)+ "]"
1337
1338        theory_data = deepcopy(new_plot)
1339        theory_data.name = "Unknown"
1340        if toggle_mode_on:
1341            new_plot.id = str(page_id) + " Model"     
1342            wx.PostEvent(self.parent, 
1343                             NewPlotEvent(group_id=str(page_id) + " Model1D",
1344                                               action="Hide"))
1345       
1346        self.page_finder[page_id].set_theory_data(new_plot)
1347        if data is None:
1348            data_id = None
1349        else:
1350            data_id = data.id
1351        self.parent.update_theory(data_id=data_id, 
1352                                       theory=new_plot,
1353                                       state=state) 
1354        current_pg = self.fit_panel.get_page_by_id(page_id)
1355        title = new_plot.title
1356
1357        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1358                                               title=title))
1359        self.page_finder[page_id].set_theory_data(new_plot)
1360        # Chisqr in fitpage
1361        if update_chisqr:
1362            wx.PostEvent(current_pg,
1363                         Chi2UpdateEvent(output=\
1364                                    self._cal_chisqr(data=data,
1365                                                     page_id=page_id,
1366                                                     index=index)))
1367        else:
1368            self._plot_residuals(page_id, data, index)
1369        msg = "Plot 2D complete !"
1370        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop"))
1371   
1372    def _draw_model2D(self, model, page_id, data=None, smearer=None,
1373                      description=None, enable2D=False,
1374                      state=None,
1375                      toggle_mode_on=False,
1376                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,
1377                      qstep=DEFAULT_NPTS,
1378                      update_chisqr=True):
1379        """
1380        draw model in 2D
1381       
1382        :param model: instance of the model to draw
1383        :param description: the description of the model
1384        :param enable2D: when True allows to draw model 2D
1385        :param qmin: the minimum value to  draw model 2D
1386        :param qmax: the maximum value to draw model 2D
1387        :param qstep: the number of division of Qx and Qy of the model to draw
1388           
1389        """
1390        x=  numpy.linspace(start=-1*qmax,
1391                               stop=qmax,
1392                               num=qstep,
1393                               endpoint=True) 
1394        y = numpy.linspace(start= -1*qmax,
1395                               stop=qmax,
1396                               num=qstep,
1397                               endpoint=True)
1398        if model is None:
1399            msg = "Panel with ID: %s does not contained model" % str(page_id)
1400            raise ValueError, msg
1401        ## use data info instead
1402        if data is not None:
1403            ## check if data2D to plot
1404            if hasattr(data, "x_bins"):
1405                enable2D = True
1406                x = data.x_bins
1407                y = data.y_bins
1408               
1409        if not enable2D:
1410            return None, None
1411        try:
1412            from model_thread import Calc2D
1413            ## If a thread is already started, stop it
1414            if (self.calc_2D is not None) and self.calc_2D.isrunning():
1415                self.calc_2D.stop()
1416            self.calc_2D = Calc2D(x=x,
1417                                    y=y,
1418                                    model=model, 
1419                                    data=data,
1420                                    page_id=page_id,
1421                                    smearer=smearer,
1422                                    qmin=qmin,
1423                                    qmax=qmax,
1424                                    qstep=qstep,
1425                                    toggle_mode_on=toggle_mode_on,
1426                                    state=state,
1427                                    completefn=self._complete2D,
1428                                    #updatefn= self._update2D,
1429                                    update_chisqr=update_chisqr)
1430
1431            self.calc_2D.queue()
1432
1433        except:
1434            raise
1435            #msg = " Error occurred when drawing %s Model 2D: " % model.name
1436            #msg += " %s" % sys.exc_value
1437            #wx.PostEvent(self.parent, StatusEvent(status=msg))
1438
1439    def _draw_model1D(self, model, page_id, data=None, smearer=None,
1440                qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, 
1441                state=None,
1442                toggle_mode_on=False,
1443                qstep=DEFAULT_NPTS, update_chisqr=True, 
1444                enable1D=True):
1445        """
1446        Draw model 1D from loaded data1D
1447       
1448        :param data: loaded data
1449        :param model: the model to plot
1450       
1451        """
1452        x=  numpy.linspace(start=qmin,
1453                           stop=qmax,
1454                           num=qstep,
1455                           endpoint=True
1456                           )
1457        if data is not None:
1458            ## check for data2D
1459            if hasattr(data,"x_bins"):
1460                return
1461            x = data.x
1462            if qmin == None :
1463                qmin == DEFAULT_QMIN
1464
1465            if qmax == None:
1466                qmax == DEFAULT_QMAX
1467        if not enable1D:
1468            return 
1469        try:
1470            from model_thread import Calc1D
1471            ## If a thread is already started, stop it
1472            if (self.calc_1D is not None) and self.calc_1D.isrunning():
1473                self.calc_1D.stop()
1474            self.calc_1D = Calc1D(x=x,
1475                                  data=data,
1476                                  model=model,
1477                                  page_id=page_id, 
1478                                  qmin=qmin,
1479                                  qmax=qmax,
1480                                  smearer=smearer,
1481                                  state=state,
1482                                  toggle_mode_on=toggle_mode_on,
1483                                  completefn=self._complete1D,
1484                                  #updatefn = self._update1D,
1485                                  update_chisqr=update_chisqr)
1486
1487            self.calc_1D.queue()
1488
1489        except:
1490            msg = " Error occurred when drawing %s Model 1D: " % model.name
1491            msg += " %s" % sys.exc_value
1492            wx.PostEvent(self.parent, StatusEvent(status=msg))
1493
1494    def _cal_chisqr(self, page_id, data=None, index=None): 
1495        """
1496        Get handy Chisqr using the output from draw1D and 2D,
1497        instead of calling expansive CalcChisqr in guithread
1498        """
1499        # default chisqr
1500        chisqr = None
1501
1502        # return None if data == None
1503        if data == None: return chisqr
1504       
1505        # Get data: data I, theory I, and data dI in order
1506        if data.__class__.__name__ == "Data2D":
1507            if index == None: 
1508                index = numpy.ones(len(data.data),ntype=bool)
1509            # get rid of zero error points
1510            index = index & (data.err_data != 0 ) 
1511            index = index & (numpy.isfinite(data.data)) 
1512            fn = data.data[index] 
1513            theory_data = self.page_finder[page_id].get_theory_data()
1514            gn = theory_data.data[index]
1515            en = data.err_data[index]
1516        else:
1517            # 1 d theory from model_thread is only in the range of index
1518            if index == None: 
1519                index = numpy.ones(len(data.y), ntype=bool)
1520            if data.dy == None or data.dy == []:
1521                dy = numpy.ones(len(data.y))
1522            else:
1523                ## Set consitently w/AbstractFitengine:
1524                # But this should be corrected later.
1525                dy = deepcopy(data.dy)
1526                dy[dy==0] = 1 
1527            fn = data.y[index] 
1528            theory_data = self.page_finder[page_id].get_theory_data()
1529            gn = theory_data.y
1530            en = dy[index]
1531
1532        # residual
1533        res = (fn - gn) / en
1534        residuals = res[numpy.isfinite(res)]
1535        # get chisqr only w/finite
1536        chisqr = numpy.average(residuals * residuals)
1537       
1538        self._plot_residuals(page_id, data, index)
1539        return chisqr
1540   
1541
1542       
1543    def _plot_residuals(self, page_id, data=None, index=None): 
1544        """
1545        Plot the residuals
1546       
1547        :param data: data
1548        :param index: index array (bool)
1549        : Note: this is different from the residuals in cal_chisqr()
1550        """
1551        if data == None: 
1552            return 
1553       
1554        # Get data: data I, theory I, and data dI in order
1555        if data.__class__.__name__ == "Data2D":
1556            # build residuals
1557            #print data
1558            residuals = Data2D()
1559            #residuals.copy_from_datainfo(data)
1560            # Not for trunk the line below, instead use the line above
1561            data.clone_without_data(len(data.data), residuals)
1562            residuals.data = None
1563            fn = data.data#[index]
1564            theory_data = self.page_finder[page_id].get_theory_data()
1565            gn = theory_data.data#[index]
1566            en = data.err_data#[index]
1567            residuals.data = (fn - gn) / en
1568            residuals.qx_data = data.qx_data#[index]
1569            residuals.qy_data = data.qy_data #[index]
1570            residuals.q_data = data.q_data#[index]
1571            residuals.err_data = numpy.ones(len(residuals.data))#[index]
1572            residuals.xmin = min(residuals.qx_data)
1573            residuals.xmax = max(residuals.qx_data)
1574            residuals.ymin = min(residuals.qy_data)
1575            residuals.ymax = max(residuals.qy_data)
1576            residuals.q_data = data.q_data#[index]
1577            residuals.mask = data.mask
1578            residuals.scale = 'linear'
1579            #print "print data",residuals
1580            # check the lengths
1581            if len(residuals.data) != len(residuals.q_data):
1582                return
1583
1584        else:
1585            # 1 d theory from model_thread is only in the range of index
1586            if data.dy == None or data.dy == []:
1587                dy = numpy.ones(len(data.y))
1588            else:
1589                ## Set consitently w/AbstractFitengine:
1590                ## But this should be corrected later.
1591                dy = deepcopy(data.dy)
1592                dy[dy==0] = 1 
1593            fn = data.y[index] 
1594            theory_data = self.page_finder[page_id].get_theory_data()
1595            gn = theory_data.y
1596            en = dy[index]
1597            # build residuals
1598            residuals = Data1D()
1599            residuals.y = (fn - gn) / en
1600            residuals.x = data.x[index]
1601            residuals.dy = numpy.ones(len(residuals.y))
1602            residuals.dx = None
1603            residuals.dxl = None
1604            residuals.dxw = None
1605            residuals.ytransform = 'y'
1606            # For latter scale changes
1607            residuals.xaxis('\\rm{Q} ', 'A^{-1}')
1608            residuals.yaxis('\\rm{Residuals} ', 'normalized')
1609           
1610        new_plot = residuals
1611        if data.id == None:
1612            data.id = data.name
1613        name  = data.id
1614        new_plot.name = "Residuals for " + str(data.name)
1615        ## allow to highlight data when plotted
1616        new_plot.interactive = True
1617        ## when 2 data have the same id override the 1 st plotted
1618        new_plot.id = new_plot.name#name + " residuals"
1619        ##group_id specify on which panel to plot this data
1620        new_plot.group_id = new_plot.id
1621        #new_plot.is_data = True
1622        ##post data to plot
1623        title = new_plot.name
1624       
1625        # plot data
1626        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))   
1627       
1628#def profile(fn, *args, **kw):
1629#    import cProfile, pstats, os
1630#    global call_result
1631#    def call():
1632#        global call_result
1633#        call_result = fn(*args, **kw)
1634#    cProfile.runctx('call()', dict(call=call), {}, 'profile.out')
1635#    stats = pstats.Stats('profile.out')
1636#    #stats.sort_stats('time')
1637#    stats.sort_stats('calls')
1638#    stats.print_stats()
1639#    os.unlink('profile.out')
1640#    return call_result
1641if __name__ == "__main__":
1642    i = Plugin()
1643   
1644   
1645   
1646   
Note: See TracBrowser for help on using the repository browser.