source: sasview/sansview/perspectives/fitting/fitting.py @ df4c3ad

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 df4c3ad was df4c3ad, checked in by Gervaise Alina <gervyh@…>, 15 years ago

slicer clear on slicer panel close
  • Property mode set to 100644
File size: 48.3 KB
Line 
1import  re,copy
2import sys, wx, logging
3import string, numpy, math
4
5from danse.common.plottools.plottables import Data2D,Theory1D
6from sans.guiframe import dataFitting
7from danse.common.plottools.PlotPanel import PlotPanel
8from sans.guicomm.events import NewPlotEvent, StatusEvent 
9from sans.guicomm.events import EVT_SLICER_PANEL,ERR_DATA,EVT_REMOVE_DATA
10from sans.guicomm.events import EVT_SLICER_PARS_UPDATE
11from sans.guiframe import dataFitting
12from sans.fit.AbstractFitEngine import Model
13
14
15from fitproblem import FitProblem
16from fitpanel import FitPanel
17from fit_thread import FitThread
18import models
19import fitpage
20
21
22DEFAULT_BEAM = 0.005
23DEFAULT_QMIN = 0.0001
24DEFAULT_QMAX = 0.13
25DEFAULT_NPTS = 50
26import time
27import thread
28from sans.fit.AbstractFitEngine import FitAbort
29
30(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent()
31class PlotInfo:
32    """
33        store some plotting field
34    """
35    _xunit = 'A^{-1}'
36    _xaxis= "\\rm{Q}"
37    _yunit = "cm^{-1}"
38    _yaxis= "\\rm{Intensity} "
39    id = "Model"
40    group_id = "Model"
41    title= None
42    info= None
43   
44   
45class Plugin:
46    """
47        Fitting plugin is used to perform fit
48    """
49    def __init__(self):
50        ## Plug-in name
51        self.sub_menu = "Fitting"
52       
53        ## Reference to the parent window
54        self.parent = None
55        #Provide list of models existing in the application
56        self.menu_mng = models.ModelManager()
57        ## List of panels for the simulation perspective (names)
58        self.perspective = []
59        #list of panel to send to guiframe
60        self.mypanels=[]
61        # reference to the current running thread
62        self.calc_2D= None
63        self.calc_1D= None
64        self.calc_fit= None
65       
66        # Start with a good default
67        self.elapsed = 0.022
68        # the type of optimizer selected, park or scipy
69        self.fitter  = None
70        #Flag to let the plug-in know that it is running stand alone
71        self.standalone=True
72        ## dictionary of page closed and id
73        self.closed_page_dict ={}
74        ## Fit engine
75        self._fit_engine = 'scipy'
76        #List of selected data
77        self.selected_data_list=[]
78        ## list of panel with slicer
79        self.main_panel=[]
80        # Log startup
81        logging.info("Fitting plug-in started")   
82        # model 2D view
83        self.model2D_id=None
84        #keep reference of the simultaneous fit page
85        self.sim_page=None
86        #dictionary containing data name and error on dy of that data
87        self.err_dy={}
88       
89   
90       
91    def populate_menu(self, id, owner):
92        """
93            Create a menu for the Fitting plug-in
94            @param id: id to create a menu
95            @param owner: owner of menu
96            @ return : list of information to populate the main menu
97        """
98        #Menu for fitting
99        self.menu1 = wx.Menu()
100       
101        #Set park engine
102        id3 = wx.NewId()
103        scipy_help= "Scipy Engine: Perform Simple fit. More in Help window...."
104        self.menu1.AppendCheckItem(id3, "Simple Fit  [Scipy]",scipy_help) 
105        wx.EVT_MENU(owner, id3,  self._onset_engine_scipy)
106       
107        id3 = wx.NewId()
108        park_help = "Park Engine: Perform Complex fit. More in Help window...."
109        self.menu1.AppendCheckItem(id3, "Complex Fit  [Park]",park_help) 
110        wx.EVT_MENU(owner, id3,  self._onset_engine_park)
111       
112        self.menu1.FindItemByPosition(0).Check(True)
113        self.menu1.FindItemByPosition(1).Check(False)
114           
115        self.menu1.AppendSeparator()
116       
117        id1 = wx.NewId()
118        simul_help = "Allow to edit fit engine with multiple model and data"
119        self.menu1.Append(id1, '&Simultaneous Page',simul_help)
120        wx.EVT_MENU(owner, id1, self.on_add_sim_page)
121   
122        #menu for model
123        menu2 = wx.Menu()
124   
125        self.menu_mng.populate_menu(menu2, owner)
126        id2 = wx.NewId()
127        owner.Bind(models.EVT_MODEL,self._on_model_menu)
128     
129        self.fit_panel.set_owner(owner)
130        self.fit_panel.set_model_list(self.menu_mng.get_model_list())
131        owner.Bind(fitpage.EVT_MODEL_BOX,self._on_model_panel)
132     
133        #create  menubar items
134        return [(id, self.menu1, "Fitting"),
135                (id2, menu2, "Model")]
136       
137   
138    def on_add_sim_page(self, event):
139        """
140            Create a page to access simultaneous fit option
141        """
142        if self.sim_page !=None:
143            msg= "Simultaneous Fit page already opened"
144            wx.PostEvent(self.parent, StatusEvent(status= msg))
145            return 
146       
147        self.sim_page= self.fit_panel.add_sim_page()
148       
149       
150       
151    def help(self, evt):
152        """
153            Show a general help dialog.
154            TODO: replace the text with a nice image
155        """
156        from helpPanel import  HelpWindow
157        frame = HelpWindow(None, -1, 'HelpWindow')   
158        frame.Show(True)
159       
160       
161    def get_context_menu(self, graph=None):
162        """
163            Get the context menu items available for P(r)
164            @param graph: the Graph object to which we attach the context menu
165            @return: a list of menu items with call-back function
166        """
167        #TODO: clean this up so that the string are not copied
168        #      multiple times.
169        self.graph=graph
170        for item in graph.plottables:
171            if item.__class__.__name__ is "Data2D":
172                if hasattr(item,"is_data"):
173                    if item.is_data:
174                        return [["Select data for fitting", \
175                         "Dialog with fitting parameters ", self._onSelect]]
176                    else:
177                        return [] 
178                return [["Select data for fitting",\
179                          "Dialog with fitting parameters ", self._onSelect]] 
180            else:
181                if item.name==graph.selected_plottable :
182                    if hasattr(item, "group_id"):
183                        if hasattr(item,"is_data"):
184                            if item.is_data:
185                                return [["Select data for fitting", \
186                                 "Dialog with fitting parameters ", self._onSelect]]
187                            else:
188                                return [] 
189                        else:
190                            return [["Select data for fitting", \
191                                 "Dialog with fitting parameters ", self._onSelect]] 
192        return []   
193
194
195    def get_panels(self, parent):
196        """
197            Create and return a list of panel objects
198        """
199        self.parent = parent
200        # Creation of the fit panel
201        self.fit_panel = FitPanel(self.parent, -1)
202        #Set the manager for the main panel
203        self.fit_panel.set_manager(self)
204        # List of windows used for the perspective
205        self.perspective = []
206        self.perspective.append(self.fit_panel.window_name)
207        # take care of saving  data, model and page associated with each other
208        self.page_finder = {}
209        #index number to create random model name
210        self.index_model = 0
211        self.index_theory= 0
212        self.parent.Bind(EVT_SLICER_PANEL, self._on_slicer_event)
213        self.parent.Bind( ERR_DATA, self._on_data_error)
214        self.parent.Bind(EVT_REMOVE_DATA, self._closed_fitpage)
215        self.parent.Bind(EVT_SLICER_PARS_UPDATE, self._onEVT_SLICER_PANEL)
216        self.parent._mgr.Bind(wx.aui.EVT_AUI_PANE_CLOSE,self._onclearslicer)   
217
218       
219        #Send the fitting panel to guiframe
220        self.mypanels.append(self.fit_panel)
221        return self.mypanels
222
223       
224     
225    def get_perspective(self):
226        """
227            Get the list of panel names for this perspective
228        """
229        return self.perspective
230   
231   
232    def on_perspective(self, event):
233        """
234            Call back function for the perspective menu item.
235            We notify the parent window that the perspective
236            has changed.
237        """
238        self.parent.set_perspective(self.perspective)
239   
240   
241    def post_init(self):
242        """
243            Post initialization call back to close the loose ends
244            [Somehow openGL needs this call]
245        """
246        self.parent.set_perspective(self.perspective)
247
248
249    def copy_data(self, item, dy=None):
250        """
251            receive a data 1D and the list of errors on dy
252            and create a new data1D data
253            @param return
254        """
255        detector=None
256        source=None
257        info = None
258        id=None
259        dxl=None
260        dxw=None
261        dx=None
262        if hasattr(item, "dxl"):
263            dxl = copy.deepcopy(item.dxl)
264        if hasattr(item, "dxw"):
265            dxw = copy.deepcopy(item.dxw)
266        if hasattr(item, "detector"):
267            detector = copy.deepcopy(item.detector)
268        if hasattr(item, "source"):
269            source = copy.deepcopy(item.source)
270        if hasattr(item ,"info"):
271            info= copy.deepcopy(item.info)
272        if hasattr(item,"id"):
273            id = copy.deepcopy(item.id)
274        if hasattr(item, "dx"):
275            dx= item.dx
276           
277       
278        data= dataFitting.Data1D(x=item.x, y=item.y,dx=dx, dy=dy, dxl=dxl, dxw=dxw)
279       
280        data.name = item.name
281        data.detector = detector
282        data.source = source
283        ## allow to highlight data when plotted
284        data.interactive = copy.deepcopy(item.interactive)
285        ## when 2 data have the same id override the 1 st plotted
286        data.id = id
287        ## info is a reference to output of dataloader that can be used
288        ## to save  data 1D as cansas xml file
289        data.info= info
290        ## If the data file does not tell us what the axes are, just assume...
291        data.xaxis(copy.deepcopy(item._xaxis),copy.deepcopy(item._xunit))
292        data.yaxis(copy.deepcopy(item._yaxis),copy.deepcopy(item._yunit))
293        ##group_id specify on which panel to plot this data
294        data.group_id = copy.deepcopy(item.group_id)
295        return data
296
297    def set_fit_range(self, page, qmin, qmax):
298        """
299            Set the fitting range of a given page
300        """
301        if page in self.page_finder.iterkeys():
302            fitproblem= self.page_finder[page]
303            fitproblem.set_range(qmin= qmin, qmax= qmax)
304                   
305    def schedule_for_fit(self,value=0,page=None,fitproblem =None): 
306        """
307            Set the fit problem field to 0 or 1 to schedule that problem to fit.
308            Schedule the specified fitproblem or get the fit problem related to
309            the current page and set value.
310            @param value : integer 0 or 1
311            @param fitproblem: fitproblem to schedule or not to fit
312        """   
313        if fitproblem !=None:
314            fitproblem.schedule_tofit(value)
315        else:
316            if page in self.page_finder.iterkeys():
317                fitproblem= self.page_finder[page]
318                fitproblem.schedule_tofit(value)
319         
320                     
321                   
322    def get_page_finder(self):
323        """ @return self.page_finder used also by simfitpage.py""" 
324        return self.page_finder
325   
326   
327    def set_page_finder(self,modelname,names,values):
328        """
329             Used by simfitpage.py to reset a parameter given the string constrainst.
330             @param modelname: the name ot the model for with the parameter has to reset
331             @param value: can be a string in this case.
332             @param names: the paramter name
333             @note: expecting park used for fit.
334        """ 
335        sim_page= self.sim_page
336        for page, value in self.page_finder.iteritems():
337            if page != sim_page:
338                list=value.get_model()
339                model = list[0]
340                if model.name== modelname:
341                    value.set_model_param(names,values)
342                    break
343
344   
345                           
346    def split_string(self,item): 
347        """
348            receive a word containing dot and split it. used to split parameterset
349            name into model name and parameter name example:
350            paramaterset (item) = M1.A
351            @return model_name =M1 , parameter name =A
352        """
353        if string.find(item,".")!=-1:
354            param_names= re.split("\.",item)
355            model_name=param_names[0]
356            param_name=param_names[1] 
357            return model_name,param_name
358       
359   
360    def stop_fit(self):
361        """
362            Stop the fit engine
363        """
364        if self.calc_fit!= None and self.calc_fit.isrunning():
365            self.calc_fit.stop()
366            wx.PostEvent(self.parent, StatusEvent(status="Fitting  \
367                is cancelled" , type="stop"))
368           
369   
370     
371    def set_smearer(self,smearer, qmin=None, qmax=None):
372        """
373            Get a smear object and store it to a fit problem
374            @param smearer: smear object to allow smearing data
375        """   
376        current_pg=self.fit_panel.get_current_page()
377        self.page_finder[current_pg].set_smearer(smearer)
378        ## draw model 1D with smeared data
379        data =  self.page_finder[current_pg].get_plotted_data()
380        model = self.page_finder[current_pg].get_model()
381        ## if user has already selected a model to plot
382        ## redraw the model with data smeared
383       
384        smear =self.page_finder[current_pg].get_smearer()
385        self.draw_model( model=model, data= data, smearer= smear,
386                qmin= qmin, qmax= qmax)
387
388   
389   
390    def draw_model(self, model, data= None,smearer= None,
391                   enable1D= True, enable2D= False,
392                   qmin= DEFAULT_QMIN, qmax= DEFAULT_QMAX, qstep= DEFAULT_NPTS):
393        """
394             Draw model.
395             @param model: the model to draw
396             @param name: the name of the model to draw
397             @param data: the data on which the model is based to be drawn
398             @param description: model's description
399             @param enable1D: if true enable drawing model 1D
400             @param enable2D: if true enable drawing model 2D
401             @param qmin:  Range's minimum value to draw model
402             @param qmax:  Range's maximum value to draw model
403             @param qstep: number of step to divide the x and y-axis
404             
405        """
406        ## draw model 1D with no loaded data
407        self._draw_model1D( model= model, data= data,enable1D=enable1D, smearer= smearer,
408                           qmin= qmin, qmax= qmax, qstep= qstep )
409        ## draw model 2D with no initial data
410        self._draw_model2D(model=model,
411                           data = data,
412                           enable2D= enable2D,
413                           qmin=qmin,
414                           qmax=qmax,
415                           qstep=qstep)
416       
417 
418                       
419    def onFit(self):
420        """
421            perform fit
422        """
423        ##  count the number of fitproblem schedule to fit
424        fitproblem_count= 0
425        for value in self.page_finder.itervalues():
426            if value.get_scheduled()==1:
427                fitproblem_count += 1
428               
429        ## if simultaneous fit change automatically the engine to park
430        if fitproblem_count >1:
431            self._on_change_engine(engine='park')
432           
433        from sans.fit.Fitting import Fit
434        self.fitter= Fit(self._fit_engine)
435       
436        if self._fit_engine=="park":
437            engineType="Simultaneous Fit"
438        else:
439            engineType="Single Fit"
440           
441        fproblemId = 0
442        current_pg=None
443        for page, value in self.page_finder.iteritems():
444            try:
445                if value.get_scheduled()==1:
446                    #Get list of parameters name to fit
447                    pars = []
448                    templist = []
449                    templist = page.get_param_list()
450                    for element in templist:
451                        name = str(element[1])
452                        pars.append(name)
453                    #Set Engine  (model , data) related to the page on
454                    self._fit_helper( current_pg=page, value=value,pars=pars,
455                                      id=fproblemId, title= engineType ) 
456                    fproblemId += 1 
457                    current_pg= page
458            except:
459                msg= "%s error: %s" % (engineType,sys.exc_value)
460                wx.PostEvent(self.parent, StatusEvent(status= msg ))
461                return 
462        #Do the simultaneous fit
463        try:
464            ## If a thread is already started, stop it
465            if self.calc_fit!= None and self.calc_fit.isrunning():
466                self.calc_fit.stop()
467           
468            wx.PostEvent(self.parent, StatusEvent(status="Start the computation",
469                                        curr_thread=self.calc_fit,type="start"))
470            wx.PostEvent(self.parent, StatusEvent(status="Computing...",
471                                        curr_thread=self.calc_fit,type="progress"))
472            ## perform single fit
473            if self._fit_engine=="scipy":
474                qmin, qmax= current_pg.get_range()
475                self.calc_fit=FitThread(parent =self.parent,
476                                        fn= self.fitter,
477                                       cpage=current_pg,
478                                       pars= pars,
479                                       completefn= self._single_fit_completed,
480                                       updatefn=self._updateFit)
481                     
482            else:
483                ## Perform more than 1 fit at the time
484                self.calc_fit=FitThread(parent =self.parent,
485                                        fn= self.fitter,
486                                       completefn= self._simul_fit_completed,
487                                       updatefn=self._updateFit)
488            self.calc_fit.queue()
489            self.calc_fit.ready(2.5)
490       
491        except FitAbort:
492            print "in pluging"
493        except:
494            msg= "%s error: %s" % (engineType,sys.exc_value)
495            wx.PostEvent(self.parent, StatusEvent(status= msg ,type="stop"))
496            return 
497           
498           
499           
500    def _onEVT_SLICER_PANEL(self, event):
501        """
502            receive and event telling to update a panel with a name starting with
503            event.panel_name. this method update slicer panel for a given interactor.
504            @param event: contains type of slicer , paramaters for updating the panel
505            and panel_name to find the slicer 's panel concerned.
506        """
507       
508        for item in self.parent.panels:
509            if self.parent.panels[item].window_caption.startswith(event.panel_name):
510                self.parent.panels[item].set_slicer(event.type, event.params)
511               
512        self.parent._mgr.Update()
513               
514           
515           
516    def _closed_fitpage(self, event):   
517        """
518            request fitpanel to close a given page when its unique data is removed
519            from the plot
520        """   
521        self.fit_panel._close_fitpage(event.data) 
522       
523       
524    def _add_page_onmenu(self, name,fitproblem=None):
525        """
526            Add name of a closed page of fitpanel in a menu
527        """
528        list = self.menu1.GetMenuItems()
529        for item in list:
530            if name == item.GetItemLabel():
531                self.closed_page_dict[name][1] = fitproblem
532               
533        if not name in self.closed_page_dict.keys():   
534            # Post paramters
535            event_id = wx.NewId()
536            self.menu1.Append(event_id, name, "Show %s fit panel" % name)
537            self.closed_page_dict[name]= [event_id, fitproblem]
538            wx.EVT_MENU(self.parent,event_id,  self._open_closed_page)
539       
540       
541    def _open_closed_page(self, event):   
542        """
543            reopen a closed page
544        """
545        for name, value in self.closed_page_dict.iteritems():
546            if event.GetId() in value:
547                id,fitproblem = value
548                if name !="Model":
549                    data= fitproblem.get_fit_data()
550                    page = self.fit_panel.add_fit_page(data= data,reset=True)
551                    if fitproblem != None:
552                        self.page_finder[page]=fitproblem
553                        if self.sim_page != None:
554                            self.sim_page.draw_page()
555                           
556                else:
557                    model = fitproblem
558                    self.fit_panel.add_model_page(model=model, topmenu=True,
559                                                  reset= True)
560                    break
561       
562       
563    def _reset_schedule_problem(self, value=0):
564        """
565             unschedule or schedule all fitproblem to be fit
566        """
567        for page, fitproblem in self.page_finder.iteritems():
568            fitproblem.schedule_tofit(value)
569           
570    def _fit_helper(self,current_pg,pars,value, id, title="Single Fit " ):
571        """
572            helper for fitting
573        """
574        metadata = value.get_fit_data()
575        model = value.get_model()
576        smearer = value.get_smearer()
577        qmin , qmax = value.get_range()
578        self.fit_id =id
579        #Create list of parameters for fitting used
580        templist=[]
581        pars=pars
582        try:
583            ## create a park model and reset parameter value if constraint
584            ## is given
585            new_model = Model(model)
586            param = value.get_model_param()
587            if len(param)>0:
588                for item in param:
589                    param_value = item[1]
590                    param_name = item[0]
591                    ## check if constraint
592                    if param_value !=None and param_name != None:
593                        new_model.parameterset[ param_name].set( param_value )
594           
595            #Do the single fit
596            self.fitter.set_model(new_model, self.fit_id, pars)
597           
598            self.fitter.set_data(data=metadata,Uid=self.fit_id,
599                                 smearer=smearer,qmin= qmin,qmax=qmax )
600           
601            self.fitter.select_problem_for_fit(Uid= self.fit_id,
602                                               value= value.get_scheduled())
603            value.clear_model_param()
604        except:
605            msg= title +" error: %s" % sys.exc_value
606            wx.PostEvent(self.parent, StatusEvent(status= msg, type="stop"))
607            return
608       
609    def _onSelect(self,event):
610        """
611            when Select data to fit a new page is created .Its reference is
612            added to self.page_finder
613        """
614        self.panel = event.GetEventObject()
615        for plottable in self.panel.graph.plottables:
616            if plottable.name == self.panel.graph.selected_plottable:
617                #if not hasattr(plottable, "is_data"):
618                   
619                if  plottable.__class__.__name__=="Theory1D":
620                    dy=numpy.zeros(len(plottable.y))
621                    if hasattr(plottable, "dy"):
622                        dy= copy.deepcopy(plottable.dy)
623                       
624                    item= self.copy_data(plottable, dy)
625                    item.group_id += "data1D"
626                    item.id +="data1D"
627                    item.is_data= False
628                    title = item.name
629                    wx.PostEvent(self.parent, NewPlotEvent(plot=item, title=str(title)))
630                else:
631                    item= self.copy_data(plottable, plottable.dy) 
632                    item.is_data=True
633                   
634                ## put the errors values back to the model if the errors were hiden
635                ## before sending them to the fit engine
636                if len(self.err_dy)>0:
637                    if item.name in  self.err_dy.iterkeys():
638                        dy= self.err_dy[item.name]
639                        data= self.copy_data(item, dy)
640                        data.is_data= item.is_data
641                    else:
642                        data= self.copy_data(item, item.dy)
643                        data.is_data= item.is_data
644                       
645                       
646                else:
647                    if item.dy==None:
648                        dy= numpy.zeros(len(item.y))
649                        data= self.copy_data(item, dy)
650                        data.is_data=item.is_data
651                    else:
652                        data= self.copy_data(item,item.dy)
653                        data.is_data=item.is_data
654                       
655            else:
656                if plottable.__class__.__name__ !="Data2D":
657                    return
658                ## Data2D case
659                if not hasattr(plottable, "is_data"):
660                    item= copy.deepcopy(plottable)
661                    item.group_id += "data2D"
662                    item.id +="data2D"
663                    item.is_data= False
664                    title = item.name
665                    title += " Fit"
666                    data = item
667                    wx.PostEvent(self.parent, NewPlotEvent(plot=item, title=str(title)))
668                else:
669                    item= copy.deepcopy(plottable )
670                    data= copy.deepcopy(plottable )
671                    item.is_data=True
672                    data.is_data=True
673               
674            ## create anew page                   
675            if item.name == self.panel.graph.selected_plottable or\
676                 item.__class__.__name__ is "Data2D":
677                try:
678                    page = self.fit_panel.add_fit_page(data)
679                    # add data associated to the page created
680                    if page !=None:   
681                        #create a fitproblem storing all link to data,model,page creation
682                        if not page in self.page_finder.keys():
683                            self.page_finder[page]= FitProblem()
684                        ## item is almost the same as data but contains
685                        ## axis info for plotting
686                        self.page_finder[page].add_plotted_data(item)
687                        self.page_finder[page].add_fit_data(data)
688
689                        wx.PostEvent(self.parent, StatusEvent(status="Page Created"))
690                    else:
691                        wx.PostEvent(self.parent, StatusEvent(status="Page was already Created"))
692                except:
693                    wx.PostEvent(self.parent, StatusEvent(status="Creating Fit page: %s"\
694                    %sys.exc_value))
695                    return
696               
697               
698    def _updateFit(self):
699        """
700            Is called when values of result are available
701        """
702        ##Sending a progess message to the status bar
703        wx.PostEvent(self.parent, StatusEvent(status="Computing..."))
704           
705    def _single_fit_completed(self,result,pars,cpage, elapsed=None):
706        """
707            Display fit result on one page of the notebook.
708            @param result: result of fit
709            @param pars: list of names of parameters fitted
710            @param current_pg: the page where information will be displayed
711            @param qmin: the minimum value of x to replot the model
712            @param qmax: the maximum value of x to replot model
713         
714        """
715        wx.PostEvent(self.parent, StatusEvent(status="Single fit \
716        complete! " ))
717     
718        try:
719            if result ==None:
720                msg= "Simple Fitting Stop !!!"
721                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
722                return
723            if numpy.any(result.pvec ==None )or not numpy.all(numpy.isfinite(result.pvec) ):
724                msg= "Single Fitting did not converge!!!"
725                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
726                return
727            for page, value in self.page_finder.iteritems():
728                if page==cpage :
729                    model= value.get_model()
730                    break
731            i = 0
732            for name in pars:
733                if result.pvec.__class__==numpy.float64:
734                    model.setParam(name,result.pvec)
735                else:
736                    model.setParam(name,result.pvec[i])
737                    i += 1
738            ## Reset values of the current page to fit result
739            cpage.onsetValues(result.fitness, result.pvec,result.stderr)
740            ## plot the current model with new param
741            metadata =  self.page_finder[cpage].get_fit_data()
742            model = self.page_finder[cpage].get_model()
743            qmin, qmax= self.page_finder[cpage].get_range()
744            smearer =self.page_finder[cpage].get_smearer()
745            #Replot models
746            msg= "Single Fit completed. plotting... %s:"%model.name
747            wx.PostEvent(self.parent, StatusEvent(status="%s " % msg))
748            self.draw_model( model=model, data= metadata, smearer= smearer,
749                             qmin= qmin, qmax= qmax)
750            wx.PostEvent(self.parent, StatusEvent(status=" " , type="stop")) 
751        except:
752            msg= "Single Fit completed but Following error occurred:%s"% sys.exc_value
753            wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
754            return
755       
756       
757    def _simul_fit_completed(self,result,pars=None,cpage=None, elapsed=None):
758        """
759            Parameter estimation completed,
760            display the results to the user
761            @param alpha: estimated best alpha
762            @param elapsed: computation time
763        """
764        wx.PostEvent(self.parent, StatusEvent(status="Simultaneous fit complete "))
765       
766        ## fit more than 1 model at the same time
767        try:
768            if result ==None:
769                msg= "Complex Fitting Stop !!!"
770                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
771                return
772            if numpy.any(result.pvec ==None )or not numpy.all(numpy.isfinite(result.pvec) ):
773                msg= "Single Fitting did not converge!!!"
774                wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
775                return
776            for page, value in self.page_finder.iteritems():
777                if value.get_scheduled()==1:
778                    model = value.get_model()
779                    metadata =  value.get_plotted_data()
780                    small_out = []
781                    small_cov = []
782                    i = 0
783                    #Separate result in to data corresponding to each page
784                    for p in result.parameters:
785                        model_name,param_name = self.split_string(p.name) 
786                        if model.name == model_name:
787                            p_name= model.name+"."+param_name
788                            if p.name == p_name:
789                                small_out.append(p.value )
790                                model.setParam(param_name,p.value) 
791                             
792                                small_cov.append(p.stderr)
793                            else:
794                                value= model.getParam(param_name)
795                                small_out.append(value )
796                                small_cov.append(None)
797                    # Display result on each page
798                    page.onsetValues(result.fitness, small_out,small_cov)
799                    #Replot models
800                    msg= "Simultaneous Fit completed. plotting... %s:"%model.name
801                    wx.PostEvent(self.parent, StatusEvent(status="%s " % msg))
802                    qmin, qmax= page.get_range()
803                    smearer =self.page_finder[page].get_smearer()
804                    self.draw_model( model=model, data= metadata, smearer=smearer,
805                                     qmin= qmin, qmax= qmax)
806            wx.PostEvent(self.parent, StatusEvent(status="", type="stop"))
807        except:
808             msg= "Simultaneous Fit completed"
809             msg +=" but Following error occurred:%s"%sys.exc_value
810             wx.PostEvent(self.parent, StatusEvent(status=msg,type="stop"))
811             return 
812             
813                           
814       
815    def _on_show_panel(self, event):
816        print "_on_show_panel: fitting"
817     
818     
819    def _onset_engine_park(self,event):
820        """
821            set engine to park
822        """
823        self._on_change_engine('park')
824       
825       
826    def _onset_engine_scipy(self,event):
827        """
828            set engine to scipy
829        """
830        self._on_change_engine('scipy')
831       
832    def _on_slicer_event(self, event):
833        """
834            Receive a panel as event and send it to guiframe
835            @param event: event containing a panel
836        """
837        if event.panel!=None:
838            new_panel = event.panel
839            #self.main_panel.append(event.main_panel)
840            # Set group ID if available
841            event_id = self.parent.popup_panel(new_panel)
842            #self.menu3.Append(event_id, new_panel.window_caption,
843            #                 "Show %s plot panel" % new_panel.window_caption)
844            # Set UID to allow us to reference the panel later
845         
846            new_panel.uid = event_id
847            self.mypanels.append(new_panel) 
848        return 
849   
850    def _onclearslicer(self, event):
851        """
852            Clear the boxslicer when close the panel associate with this slicer
853        """
854        name =event.GetPane().caption
855        key="boxsum"
856        try:
857            if name.lower().count(key)>0:
858                toks=[]
859                toks= name.lower().split(key)   
860                temp= toks[1].split()
861                panel_name= temp[0].lstrip().rstrip()
862                for item in self.parent.panels:
863                    if self.parent.panels[item].window_caption.lower().startswith(panel_name): 
864                        if hasattr(self.parent.panels[item],"slicer"):
865                            self.parent.panels[item].onClearSlicer(event)
866                            self.parent._mgr.Update()
867                            break 
868               
869            else:
870                return 
871        except:
872            raise 
873            return 
874       
875       
876       
877       
878    def _return_engine_type(self):
879        """
880            return the current type of engine
881        """
882        return self._fit_engine
883     
884     
885    def _on_change_engine(self, engine='park'):
886        """
887            Allow to select the type of engine to perform fit
888            @param engine: the key work of the engine
889        """
890        ## saving fit engine name
891        self._fit_engine = engine
892        ## change menu item state
893        if engine=="park":
894            self.menu1.FindItemByPosition(0).Check(False)
895            self.menu1.FindItemByPosition(1).Check(True)
896        else:
897            self.menu1.FindItemByPosition(0).Check(True)
898            self.menu1.FindItemByPosition(1).Check(False)
899           
900        ## post a message to status bar
901        wx.PostEvent(self.parent, StatusEvent(status="Engine set to: %s" % self._fit_engine))
902   
903        ## Bind every open fit page with a newevent to know the current fitting engine
904        import fitpage
905        event= fitpage.FitterTypeEvent()
906        event.type = self._fit_engine
907        for key in self.page_finder.keys():
908            wx.PostEvent(key, event)
909       
910   
911    def _on_model_panel(self, evt):
912        """
913            react to model selection on any combo box or model menu.plot the model 
914            @param evt: wx.combobox event
915        """
916        model = evt.model
917       
918        if model ==None:
919            return
920       
921        current_pg = self.fit_panel.get_current_page() 
922        ## make sure nothing is done on self.sim_page
923        ## example trying to call set_panel on self.sim_page
924        if current_pg != self.sim_page :
925           
926            if self.page_finder[current_pg].get_model()== None :
927               
928                model.name="M"+str(self.index_model)
929                self.index_model += 1 
930            else:
931                model.name= self.page_finder[current_pg].get_model().name
932               
933            metadata = self.page_finder[current_pg].get_plotted_data()
934           
935            # save the name containing the data name with the appropriate model
936            self.page_finder[current_pg].set_model(model)
937            qmin, qmax= current_pg.get_range()
938            self.page_finder[current_pg].set_range(qmin=qmin, qmax=qmax)
939            smearer=  self.page_finder[current_pg].get_smearer()
940            # save model name
941            self.draw_model( model=model,smearer=smearer, 
942                             data= metadata, qmin=qmin, qmax=qmax)
943           
944            if self.sim_page!=None:
945                self.sim_page.draw_page()
946       
947       
948 
949    def _on_model_menu(self, evt):
950        """
951            Plot a theory from a model selected from the menu
952            @param evt: wx.menu event
953        """
954        model = evt.model
955     
956        # Create a model page. If a new page is created, the model
957        # will be plotted automatically. If a page already exists,
958        # the content will be updated and the plot refreshed
959        self.fit_panel.add_model_page(model,topmenu=True)
960   
961   
962   
963   
964    def _update1D(self,x, output):
965        """
966            Update the output of plotting model 1D
967        """
968        wx.PostEvent(self.parent, StatusEvent(status="Plot \
969        #updating ... ",type="update"))
970        self.calc_thread.ready(0.01)
971   
972    def _fill_default_model2D(self, theory, qmax,qstep, qmin=None):
973        """
974            fill Data2D with default value
975            @param theory: Data2D to fill
976        """
977        from DataLoader.data_info import Detector, Source
978       
979        detector = Detector()
980        theory.detector.append(detector) 
981           
982        theory.detector[0].distance=1e+32
983        theory.source= Source()
984        theory.source.wavelength=2*math.pi/1e+32
985     
986        ## Create detector for Model 2D
987        xmax=2*theory.detector[0].distance*math.atan(\
988                            qmax/(4*math.pi/theory.source.wavelength))
989       
990        theory.detector[0].pixel_size.x= xmax/(qstep/2-0.5)
991        theory.detector[0].pixel_size.y= xmax/(qstep/2-0.5)
992        theory.detector[0].beam_center.x= qmax
993        theory.detector[0].beam_center.y= qmax
994        ## create x_bins and y_bins of the model 2D
995        distance   = theory.detector[0].distance
996        pixel      = qstep/2-1
997        theta      = pixel / distance / qstep#100.0
998        wavelength = theory.source.wavelength
999        pixel_width_x = theory.detector[0].pixel_size.x
1000        pixel_width_y = theory.detector[0].pixel_size.y
1001        center_x      = theory.detector[0].beam_center.x/pixel_width_x
1002        center_y      = theory.detector[0].beam_center.y/pixel_width_y
1003       
1004       
1005        size_x, size_y= numpy.shape(theory.data)
1006        for i_x in range(size_x):
1007            theta = (i_x-center_x)*pixel_width_x / distance
1008            qx = 4.0*math.pi/wavelength * math.tan(theta/2.0)
1009            theory.x_bins.append(qx)   
1010        for i_y in range(size_y):
1011            theta = (i_y-center_y)*pixel_width_y / distance
1012            qy =4.0*math.pi/wavelength * math.tan(theta/2.0)
1013            theory.y_bins.append(qy)
1014           
1015        theory.group_id ="Model"
1016        theory.id ="Model"
1017        ## determine plot boundaries
1018        theory.xmin= -qmax
1019        theory.xmax= qmax
1020        theory.ymin= -qmax
1021        theory.ymax= qmax
1022       
1023       
1024    def _get_plotting_info(self, data=None):
1025        """
1026            get plotting info from data if data !=None
1027            else use some default
1028        """
1029        my_info = PlotInfo()
1030        if data !=None:
1031            if hasattr(data,"info"):
1032                x_name, x_units = data.get_xaxis() 
1033                y_name, y_units = data.get_yaxis() 
1034               
1035                my_info._xunit = x_units
1036                my_info._xaxis = x_name
1037                my_info._yunit = y_units
1038                my_info._yaxis = y_name
1039               
1040            my_info.title= data.name
1041            if hasattr(data, "info"):
1042                my_info.info= data.info
1043            if hasattr(data, "group_id"):
1044                my_info.group_id= data.group_id
1045       
1046        return my_info
1047               
1048    def _complete1D(self, x,y, elapsed,model,data=None):
1049        """
1050            Complete plotting 1D data
1051        """ 
1052       
1053        try:
1054           
1055            new_plot = Theory1D(x=x, y=y)
1056            my_info = self._get_plotting_info( data)
1057            new_plot.name = model.name
1058            new_plot.id = my_info.id
1059            new_plot.group_id = my_info.group_id
1060           
1061            new_plot.xaxis( my_info._xaxis,  my_info._xunit)
1062            new_plot.yaxis( my_info._yaxis, my_info._yunit)
1063            if data!=None:
1064                if new_plot.id == data.id:
1065                    new_plot.id += "Model"
1066                new_plot.is_data =False 
1067           
1068            from DataLoader import data_info
1069            info= data_info.Data1D(x= new_plot.x, y=new_plot.y)
1070            info.title= new_plot.name
1071            title= my_info.title
1072            info.xaxis(new_plot._xaxis,  new_plot._xunit)
1073            info.yaxis( new_plot._yaxis, new_plot._yunit)
1074            new_plot.info = info
1075            # Pass the reset flag to let the plotting event handler
1076            # know that we are replacing the whole plot
1077            if title== None:
1078                title = "Analytical model 1D "
1079                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1080                             title= str(title), reset=True ))
1081            else:
1082                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
1083                             title= str(title)))
1084            msg = "Plot 1D  complete !"
1085            wx.PostEvent( self.parent, StatusEvent( status= msg , type="stop" ))
1086        except:
1087            msg= " Error occurred when drawing %s Model 1D: "%new_plot.name
1088            msg+= " %s"%sys.exc_value
1089            wx.PostEvent( self.parent, StatusEvent(status= msg, type="stop"  ))
1090            return 
1091       
1092                 
1093   
1094       
1095    def _update2D(self, output,time=None):
1096        """
1097            Update the output of plotting model
1098        """
1099        wx.PostEvent(self.parent, StatusEvent(status="Plot \
1100        #updating ... ",type="update"))
1101        self.calc_thread.ready(0.01)
1102       
1103       
1104    def _complete2D(self, image,data, model,  elapsed,qmin, qmax,qstep=DEFAULT_NPTS):
1105        """
1106            Complete get the result of modelthread and create model 2D
1107            that can be plot.
1108        """
1109     
1110   
1111        err_image = numpy.zeros(numpy.shape(image))
1112       
1113        theory= Data2D(image= image , err_image= err_image)
1114        theory.name= model.name
1115       
1116        if data ==None:
1117            self._fill_default_model2D(theory= theory, qmax=qmax,qstep=qstep, qmin= qmin)
1118       
1119        else:
1120            theory.id= data.id+"Model"
1121            theory.group_id= data.name+"Model"
1122            theory.x_bins= data.x_bins
1123            theory.y_bins= data.y_bins
1124            theory.detector= data.detector
1125            theory.source= data.source
1126            theory.is_data =False 
1127            ## plot boundaries
1128            theory.ymin= data.ymin
1129            theory.ymax= data.ymax
1130            theory.xmin= data.xmin
1131            theory.xmax= data.xmax
1132     
1133       
1134        ## plot
1135        wx.PostEvent(self.parent, NewPlotEvent(plot=theory,
1136                         title="Analytical model 2D ", reset=True ))
1137        msg = "Plot 2D complete !"
1138        wx.PostEvent( self.parent, StatusEvent( status= msg , type="stop" ))
1139         
1140    def _on_data_error(self, event):
1141        """
1142            receives and event from plotting plu-gins to store the data name and
1143            their errors of y coordinates for 1Data hide and show error
1144        """
1145        self.err_dy= event.err_dy
1146         
1147    def _draw_model2D(self,model,data=None,description=None, enable2D=False,
1148                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS):
1149        """
1150            draw model in 2D
1151            @param model: instance of the model to draw
1152            @param description: the description of the model
1153            @param enable2D: when True allows to draw model 2D
1154            @param qmin: the minimum value to  draw model 2D
1155            @param qmax: the maximum value to draw model 2D
1156            @param qstep: the number of division of Qx and Qy of the model to draw
1157           
1158        """
1159       
1160        x=  numpy.linspace(start= -1*qmax,
1161                               stop= qmax,
1162                               num= qstep,
1163                               endpoint=True ) 
1164        y = numpy.linspace(start= -1*qmax,
1165                               stop= qmax,
1166                               num= qstep,
1167                               endpoint=True )
1168        ## use data info instead
1169        if data !=None:
1170            ## check if data2D to plot
1171            if hasattr(data, "x_bins"):
1172                enable2D = True
1173                x= data.x_bins
1174                y= data.y_bins
1175           
1176        if not enable2D:
1177            return
1178        try:
1179            from model_thread import Calc2D
1180            ## If a thread is already started, stop it
1181            if self.calc_2D != None and self.calc_2D.isrunning():
1182                self.calc_2D.stop()
1183            self.calc_2D = Calc2D(  x= x,
1184                                    y= y,
1185                                    model= model, 
1186                                    data = data,
1187                                    qmin= qmin,
1188                                    qmax= qmax,
1189                                    qstep= qstep,
1190                                    completefn= self._complete2D,
1191                                    updatefn= self._update2D )
1192            self.calc_2D.queue()
1193           
1194        except:
1195            msg= " Error occurred when drawing %s Model 2D: "%model.name
1196            msg+= " %s"%sys.exc_value
1197            wx.PostEvent( self.parent, StatusEvent(status= msg ))
1198            return 
1199   
1200    def _draw_model1D(self, model, data=None, smearer= None,
1201                qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep= DEFAULT_NPTS,enable1D= True):
1202        """
1203            Draw model 1D from loaded data1D
1204            @param data: loaded data
1205            @param model: the model to plot
1206        """
1207         
1208        x=  numpy.linspace(start= qmin,
1209                           stop= qmax,
1210                           num= qstep,
1211                           endpoint=True
1212                           )
1213        if data!=None:
1214            ## check for data2D
1215            if hasattr(data,"x_bins"):
1216                return
1217            x = data.x
1218            if qmin == DEFAULT_QMIN :
1219                qmin = min(data.x)
1220            if qmax == DEFAULT_QMAX:
1221                qmax = max(data.x) 
1222           
1223       
1224        if not enable1D:
1225            return
1226   
1227        try:
1228            from model_thread import Calc1D
1229            ## If a thread is already started, stop it
1230            if self.calc_1D!= None and self.calc_1D.isrunning():
1231                self.calc_1D.stop()
1232            self.calc_1D= Calc1D( x= x,
1233                                  data = data,
1234                                  model= model, 
1235                                  qmin = qmin,
1236                                  qmax = qmax,
1237                                  smearer = smearer,
1238                                  completefn = self._complete1D,
1239                                  updatefn = self._update1D  )
1240            self.calc_1D.queue()
1241           
1242        except:
1243            msg= " Error occurred when drawing %s Model 1D: "%model.name
1244            msg+= " %s"%sys.exc_value
1245            wx.PostEvent( self.parent, StatusEvent(status= msg ))
1246            return 
1247           
1248   
1249
1250
1251   
1252if __name__ == "__main__":
1253    i = Plugin()
1254   
1255   
1256   
1257   
Note: See TracBrowser for help on using the repository browser.