Source Code for Module reflectometry.model1d.adaptor.reflModelBuilder

  1  import os 
  2  import sys 
  3  import traceback 
  4  import wx 
  5   
  6  from reflectometry.model1d.profileview.plotReflPanel import ReflPanel 
  7  from reflectometry.model1d.profileview.plotInfoPanel import InfoPanel 
  8  from reflectometry.model1d.profileview.reflutils     import decodeP 
  9  from reflectometry.model1d.model.bspline import BSpline 
 10  from reflectometry.model1d.model.tetheredPolymer import TetheredPolymer 
 11   
 12  from park.parkAui.common.fittingModelBuilder import FittingModelBuilder 
 13  from park.parkAui.common.parkEvent import MODEL_UPDATE, MODEL_ADD,MODEL_REMOVE,\ 
 14                                            PARAMETER_SHOW, ParkParameterEvent, \ 
 15                                            wxEVT_PARK_PARAMETER 
 16  from park import THEORY_TAG 
 17  from xmlProfile import XmlProfile, PROFILE_TAG 
 18   
 19  THEORY_NAME = 'reflectometry.model1d.adaptor.reflTheory.ReflTheory' 
 20   
 21   
 22   
 23 -class ReflModelBuilder(FittingModelBuilder): 
 24   
 25 -    def _initContextMenu(self): 
 26          return None 
 27   
 28   
 29 -    def _init_ctrls(self): 
 30          pass 
 31   
 32 -    def _init_sizers(self): 
 33          pass 
 34   
 35 -    def _bind_ctrls(self): 
 36          pass 
 37   
 38   
 39 -    def __init__(self, 
 40                   parent, 
 41                   id=-1, 
 42                   pos   = wx.DefaultPosition, 
 43                   size  = wx.DefaultSize, 
 44                   style = wx.TAB_TRAVERSAL 
 45                   ): 
 46          super(ReflModelBuilder, self).__init__(parent, id=id, pos=pos, 
 47                                                 size=size, style=style) 
 48          self.parent = parent 
 49   
 50          self.modelPanel  = ReflPanel(self) 
 51          self.infopanel   = InfoPanel(self) 
 52          self._modelName  = None 
 53          self._modelTitle = None 
 54   
 55          sizer = wx.BoxSizer( wx.VERTICAL ) 
 56          sizer.Add(self.modelPanel, 1, border=1, flag=wx.LEFT|wx.TOP|wx.GROW ) 
 57          self.SetSizer(sizer) 
 58   
 59   
 60 -    def SetModel(self, model): 
 61          self.model = model 
 62          self._modelName = model.name 
 63   
 64          setattr(self.model, THEORY_TAG, self._getTheoryName() ) 
 65          self.modelPanel.SetModel(model) 
 66   
 67   
 68 -    def refreshModel(self, model): 
 69          self.model = model 
 70          self._modelName = model.name 
 71   
 72          setattr(self.model, THEORY_TAG, self._getTheoryName() ) 
 73          self.modelPanel.refreshModel() 
 74   
 75   
 76 -    def GetModelName(self): 
 77          return self._modelName 
 78   
 79   
 80 -    def _setModel(self): 
 81          self.modelPanel._setModel( ) 
 82   
 83   
 84 -    def get_title(self): 
 85          if hasattr(self.model, 'title'): 
 86              return self.model.title 
 87   
 88          if self._modelTitle != None: 
 89              return self._modelTitle 
 90   
 91          if self._modelName != None: 
 92              return self._modelName 
 93   
 94   
 95 -    def set_title(self, title=None): 
 96          self._modelTitle = title 
 97          self.model.title = title 
 98   
 99   
100 -    def _getTheoryName(self): 
101          return THEORY_NAME 
102   
103   
104 -    def UpdateViewer(self): 
105          pass 
106          #self.modelPanel.UpdateViewer() 
107   
108   
109 -    def UpdateParameterViewer(self, names, value): 
110          self.modelPanel.UpdateViewer(names, value) 
111   
112   
113 -    def _setEditMode(self): 
114          pass 
115   
116   
117 -    def _updateScalarValue(self, pm, Pname, val): 
118   
119          changed = False 
120          if   Pname == "depth": 
121              if  pm.depth != val: 
122                  pm.depth = val;   changed = True 
123          elif Pname == "rough": 
124              if  pm.rough != val: 
125                  pm.rough = val;   changed = True 
126          elif Pname == "rho": 
127              if  pm.rho != val: 
128                  pm.rho = val;     changed = True 
129          elif Pname == "mu": 
130              if  pm.mu != val: 
131                  pm.mu = val;      changed = True 
132          elif Pname == "phi": 
133              if  pm.phi != val: 
134                  pm.phi = val;     changed = True 
135          elif Pname == "theta": 
136              if  pm.theta != val: 
137                  pm.theta = val;   changed = True 
138          else: 
139              pass 
140   
141          return changed 
142   
143   
144   
145 -    def _updateFactoryValue(self, pm, Pname, idx, val): 
146   
147          changed = True 
148          if   Pname == "rho": 
149              _pm = decodeP(pm.rho) 
150              try: 
151                  _pm._valList[idx] = val 
152                  pm.rho = _pm.build() 
153              except: 
154                  pass 
155   
156          elif Pname == "mu": 
157              _pm = decodeP( pm.mu ) 
158              _pm._valList[idx] = val 
159              pm.mu  = _pm.build() 
160   
161          elif Pname == "phi": 
162              _pm = decodeP( pm.phi ) 
163              _pm._valList[idx] = val 
164              pm.phi  = _pm.build() 
165   
166          elif Pname == "theta": 
167              _pm = decodeP( pm.theta ) 
168              _pm._valList[idx] = val 
169              pm.theta  = _pm.build() 
170   
171          else:  changed = False 
172   
173          return changed 
174   
175   
176   
177 -    def _updateParValue(self, Lname, Pname, val): 
178          pm = self._getReflParameter(Lname) 
179   
180          _pars = Pname.split('_') 
181          if len(_pars) == 1: 
182              return self._updateScalarValue( pm, Pname, val) 
183          else: 
184              _tname=['polymerSLD', 'solventSLD', 'L0', 'phi0', 'power'] 
185              if _pars[-1].strip() in _tname: 
186                  for i in xrange(5): 
187                      if _pars[-1].strip() == _tname[i]: 
188                          idx =  i 
189              else: 
190                  idx = int( _pars[-1].strip() ) 
191              #print "UU", _pars, idx, val 
192              return self._updateFactoryValue(pm, 
193                                              _pars[0], 
194                                              idx, 
195                                              val 
196                                              ) 
197   
198   
199 -    def _getReflParameter(self, Lname ): 
200          return self.model.getChild( Lname ) 
201   
202   
203 -    def getEnds_Rhos(self): 
204          try: 
205              layerRho = self.modelPanel.model.Lrho 
206              return [layerRho[0]._val, layerRho[-1]._val] 
207          except: 
208              return [-1, -1] 
209   
210   
211 -    def _refreshProfile2Model(self): 
212   
213          (_z, _p) = self.modelPanel.model.getCurrProfiles() 
214   
215          try: 
216              # get Current profile 
217              prof = self.model.getXmlDataset().getChildren(PROFILE_TAG)[0] 
218          except: 
219              prof = XmlProfile() 
220              prof.checkXmlDataArray( len(_p)+1 ) 
221              # add profile to dataset of a model at first time 
222              self.model.getXmlDataset().addChild(prof) 
223   
224          try: 
225              prof.setDepthData(_z ) 
226              prof.setLayersData( _p ) 
227          except: 
228              pass 
229   
230   
231 -    def _refresh( self, names, Val): 
232   
233          ( Lname, Pname ) = names 
234          #print names, Val 
235          if self._updateParValue( Lname, Pname, Val ): 
236   
237              # refresh profile to model when 
238              self._refreshProfile2Model() 
239   
240              names.insert(0, self.model.name) 
241   
242              #print names, Val 
243              self._fireParameterEvent( names, Val) 
244   
245   
246 -    def _show(self, names): 
247          """ fire an event to show the specific attributes of the model""" 
248          names.insert(0, self.model.name) 
249          evt = ParkParameterEvent(wxEVT_PARK_PARAMETER , 
250                                   self.GetId(), 
251                                   None, 
252                                   names, 
253                                   None, 
254                                   self.model, 
255                                   PARAMETER_SHOW 
256                                   ) 
257          self.GetEventHandler().ProcessEvent(evt) 
258   
259   
260 -    def OnUpdateModel(self, event): 
261          self._fireModelEvent(MODEL_UPDATE) 
262