Changeset 831149e in sasview for guitools


Ignore:
Timestamp:
Apr 15, 2008 2:49:58 PM (17 years ago)
Author:
Gervaise Alina <gervyh@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
88e7d08
Parents:
3de85b8
Message:

working better .Since have to think about the zoom

Location:
guitools
Files:
1 added
6 edited

Legend:

Unmodified
Added
Removed

  • guitools/LineModel.py

    r6cfe703 r831149e  
    3030        ## Define parameters 
    3131        self.params = {} 
    32         self.params['A'] = 10.0 
    33         self.params['B'] = 10.0 
     32        self.params['A'] = 1.0 
     33        self.params['B'] = 1.0 
    3434 
    3535        ## Parameter details [units, min, max] 

  • guitools/PlotPanel.py

    rbceddd6 r831149e  
    88import os 
    99import fittings 
     10import transform 
    1011from canvas import FigureCanvas 
    1112#TODO: make the plottables interactive 
    … …  
    5960        #User scale 
    6061        self.xscales ="x" 
    61         self.yscales ="Log(y)" 
     62        self.yscales ="log10(y)" 
    6263        # keep track if the previous transformation of x and y in Property dialog 
    6364        self.prevXtrans =" " 
    … …  
    101102            self._onEVT_FUNC_PROPERTY() 
    102103        dial.Destroy() 
    103              
    104     def toX(self,x,y=None): 
    105         """ 
    106             This function is used to load value on Plottable.View 
    107             @param x: Float value 
    108             @return x, 
    109         """ 
    110         return x 
    111      
    112     def toX2(self,x,y=None): 
    113         """ 
    114             This function is used to load value on Plottable.View 
    115             Calculate x^(2) 
    116             @param x: float value 
    117         """ 
    118         return x*x 
    119      
    120     def fromX2(self,x,y=None): 
    121          """ 
    122              This function is used to load value on Plottable.View 
    123             Calculate square root of x 
    124             @param x: float value 
    125          """ 
    126          if not x >=0 : 
    127              raise ValueError, "square root of a negative value " 
    128          else: 
    129              return math.sqrt(x) 
    130     def toLogX(self,x,y=None): 
    131         """ 
    132             This function is used to load value on Plottable.View 
    133             calculate log x 
    134             @param x: float value 
    135         """ 
    136         if not x > 0: 
    137             raise ValueError, "Log(X)of a negative value " 
    138         else: 
    139             return math.log(x) 
    140          
    141     def toOneOverX(self,x,y=None): 
    142         if x !=0: 
    143             return 1/x 
    144         else: 
    145             raise ValueError,"cannot divide by zero" 
    146     def toOneOverSqrtX(self,x=None,y=None): 
    147         if y!=None: 
    148             if y > 0: 
    149                 return 1/math.sqrt(y) 
    150             else: 
    151                 raise ValueError,"cannot be computed" 
    152         if x!= None: 
    153             if x > 0: 
    154                 return 1/math.sqrt(x) 
    155             else: 
    156                 raise ValueError,"cannot be computed" 
    157          
    158     def toLogYX2(self,x,y): 
    159         if y*(x**2) >0: 
    160             return math.log(y*(x**2)) 
    161         else: 
    162              raise ValueError,"cannot be computed" 
    163           
    164           
    165     def toYX2(self,x,y): 
    166         return (x**2)*y 
    167      
    168      
    169     def toXY(self,x,y): 
    170         return x*y 
    171      
    172      
    173     def toLogXY(self,x,y): 
    174         """ 
    175             This function is used to load value on Plottable.View 
    176             calculate log x 
    177             @param x: float value 
    178         """ 
    179         if not x*y > 0: 
    180             raise ValueError, "Log(X*Y)of a negative value " 
    181         else: 
    182             return math.log(x*y) 
    183          
    184     def fromLogXY(self,x): 
    185         """ 
    186             This function is used to load value on Plottable.View 
    187             Calculate e^(x) 
    188             @param x: float value 
    189         """ 
    190         return math.exp(x*y) 
    191      
     104   
    192105    def set_yscale(self, scale='linear'): 
    193106        """ 
    … …  
    412325        for item in list: 
    413326            if ( self.xscales=="x" ): 
    414                 item.transform_x(  self.toX, self.errToX ) 
     327                item.transform_x( transform.toX,transform.errToX ) 
    415328                self.set_xscale("linear") 
    416329                name, units = item.get_xaxis() 
    … …  
    418331                 
    419332            if ( self.xscales=="x^(2)" ): 
    420                 item.transform_x(  self.toX2, self.errToX2 ) 
     333                item.transform_x( transform.toX2,transform.errToX2 ) 
    421334                self.set_xscale('linear') 
    422335                name, units = item.get_xaxis() 
    423336                self.graph.xaxis("%s^{2}" % name,  "%s^{-2}" % units) 
    424337                 
    425             if (self.xscales=="Log(x)" ): 
    426                 item.transform_x(  self.toX, self.errToLogX ) 
     338            if (self.xscales=="log10(x)" ): 
     339                item.transform_x( transform.toX, transform.errToLogX ) 
    427340                self.set_xscale("log") 
    428341                name, units = item.get_xaxis() 
    429342                self.graph.xaxis("%s" % name,  "%s^{-1}" % units) 
    430343                 
     344            if ( self.yscales=="ln(y)" ): 
     345                item.transform_y( transform.toLogX, transform.errToLogX ) 
     346                self.set_yscale("linear") 
     347                name, units = item.get_yaxis() 
     348                self.graph.yaxis("%s" % name,  "%s^{-1}" % units) 
     349                 
    431350            if ( self.yscales=="y" ): 
    432                 item.transform_y(  self.toX, self.errToX ) 
     351                item.transform_y( transform.toX, transform.errToX ) 
    433352                self.set_yscale("linear") 
    434353                name, units = item.get_yaxis() 
    435354                self.graph.yaxis("%s" % name,  "%s^{-1}" % units) 
    436355                 
    437             if ( self.yscales=="Log(y)" ):  
    438                 item.transform_y(  self.toX, self.errToLogX) 
     356            if ( self.yscales=="log10(y)" ):  
     357                item.transform_y( transform.toX, transform.errToLogX) 
    439358                self.set_yscale("log")   
    440359                name, units = item.get_yaxis() 
    … …  
    442361                 
    443362            if ( self.yscales=="y^(2)" ): 
    444                 item.transform_y(  self.toX2, self.errToX2 )     
     363                item.transform_y( transform.toX2, transform.errToX2 )     
    445364                self.set_yscale("linear") 
    446365                name, units = item.get_yaxis() 
    447366                self.graph.yaxis("%s^2" % name,  "%s^{-2}" % units) 
    448367            if ( self.yscales =="1/y"): 
    449                 item.transform_y( self.toOneOverX ,self.errOneOverX ) 
     368                item.transform_y( transform.toOneOverX , transform.errOneOverX ) 
    450369                self.set_yscale("linear") 
    451370                name, units = item.get_yaxis() 
    452371                self.graph.yaxis("%s" % name,  "%s" % units) 
    453372            if ( self.yscales =="1/sqrt(y)" ): 
    454                 item.transform_y( self.toOneOverSqrtX ,self.errOneOverSqrtX ) 
     373                item.transform_y( transform.toOneOverSqrtX ,transform.errOneOverSqrtX ) 
    455374                self.set_yscale("linear") 
    456375                name, units = item.get_yaxis() 
    457376                self.graph.yaxis("%s" %name,  "%s" % units) 
    458377                 
    459             if ( self.yscales =="Log(y*x)"): 
    460                 item.transform_y( self.toLogXY ,self.errToLogXY ) 
     378            if ( self.yscales =="ln(y*x)"): 
     379                item.transform_y( transform.toLogXY ,transform.errToLogXY ) 
    461380                self.set_yscale("linear") 
    462381                yname, yunits = item.get_yaxis() 
    463382                xname, xunits = item.get_xaxis() 
    464383                self.graph.yaxis("%s%s" % (yname,xname),  "%s^{-1}%s^{-1}" % (yunits,xunits)) 
    465             if ( self.yscales =="Log(y*x^(2)"): 
    466                 item.transform_y( self.toYX2 ,self.errToYX2 ) 
     384                 
     385            if ( self.yscales =="ln(y*x^(2)"): 
     386                item.transform_y( transform.toYX2 ,transform.ToYX2 ) 
    467387                self.set_yscale("linear") 
    468388                yname, yunits = item.get_yaxis() 
    469389                xname, xunits = item.get_xaxis() 
    470390                self.graph.yaxis("%s%s^{2}" % (yname,xname),  "%s^{-1}%s^{-2}" % (yunits,xunits)) 
     391             
     392            if ( self.yscales =="ln(y*x^(4))"): 
     393                item.transform_y( transform.toLogYX4 ,transform.errToLogYX4 ) 
     394                self.set_yscale("linear") 
     395                yname, yunits = item.get_yaxis() 
     396                xname, xunits = item.get_xaxis() 
     397                self.graph.yaxis("%s%s^{4}" % (yname,xname),  "%s^{-1}%s^{-4}" % (yunits,xunits)) 
    471398    
    472399        self.prevXtrans = self.xscales  
    … …  
    475402        self.graph.render(self) 
    476403        self.subplot.figure.canvas.draw_idle() 
    477          
    478     def errToX(self,x,y=None,dx=None,dy=None): 
    479         """ 
    480             calculate error of x**2 
    481             @param x: float value 
    482             @param dx: float value 
    483         """ 
    484         return dx 
    485      
    486      
    487     def errToX2(self,x,y=None,dx=None,dy=None): 
    488         """ 
    489             calculate error of x**2 
    490             @param x: float value 
    491             @param dx: float value 
    492         """ 
    493         if  dx != None: 
    494             err = 2*x*dx 
    495             if math.fabs(err) >= math.fabs(x): 
    496                 err = 0.9*x 
    497             return math.fabs(err) 
    498         else: 
    499             return 0.0 
    500     def errFromX2(self,x,y=None,dx=None,dy=None): 
    501         """ 
    502             calculate error of sqrt(x) 
    503             @param x: float value 
    504             @param dx: float value 
    505         """ 
    506         if (x > 0): 
    507             if(dx != None): 
    508                 err = dx/(2*math.sqrt(x)) 
    509             else: 
    510                 err = 0 
    511             if math.fabs(err) >= math.fabs(x): 
    512                 err = 0.9*x     
    513         else: 
    514             err = 0.9*x 
    515             
    516             return math.fabs(err) 
    517          
    518     def errToLogX(self,x,y=None,dx=None,dy=None): 
    519         """ 
    520             calculate error of Log(x) 
    521             @param x: float value 
    522             @param dx: float value 
    523         """ 
    524         if math.fabs(dx) >= math.fabs(x): 
    525             return 0.9*x 
    526         return dx 
    527      
    528     def errToXY(self, x, y, dx=None, dy=None): 
    529         if dx==None: 
    530             dx=0 
    531         if dy==None: 
    532             dy=0 
    533         err =math.sqrt((y*dx)**2 +(x*dy)**2) 
    534         if err >= math.fabs(x): 
    535             err =0.9*x 
    536         return err  
    537      
    538     def errToYX2(self, x, y, dx=None, dy=None): 
    539         if dx==None: 
    540             dx=0 
    541         if dy==None: 
    542             dy=0 
    543         err =math.sqrt((2*x*y*dx)**2 +((x**2)*dy)**2) 
    544         if err >= math.fabs(x): 
    545             err =0.9*x 
    546         return err  
    547          
    548     def errToLogXY(self,x,y,dx=None, dy=None): 
    549         """ 
    550             calculate error of Log(xy) 
    551         """ 
    552         if (x!=0) and (y!=0): 
    553             if dx == None: 
    554                 dx = 0 
    555             if dy == None: 
    556                 dy = 0 
    557             err = (dx/x)**2 + (dy/y)**2 
    558             if  math.sqrt(math.fabs(err)) >= math.fabs(x): 
    559                 err= 0.9*x 
    560         else: 
    561             raise ValueError, "cannot compute this error" 
    562         
    563         return math.sqrt(math.fabs(err)) 
    564          
    565     def errToLogYX2(self,x,y,dx=None, dy=None): 
    566         """ 
    567             calculate error of Log(yx**2) 
    568         """ 
    569         if (x > 0) and (y > 0): 
    570             if (dx == None): 
    571                 dx = 0 
    572             if (dy == None): 
    573                 dy = 0 
    574             err = 4*(dx**2)/(x**2) + (dy**2)/(y**2) 
    575             if math.fabs(err) >= math.fabs(x): 
    576                 err =0.9*x 
    577         else: 
    578              raise ValueError, "cannot compute this error" 
    579           
    580         return math.sqrt(math.fabs(err))  
    581              
    582     def errOneOverX(self,x,y=None,dx=None, dy=None): 
    583         """ 
    584              calculate error on 1/x 
    585         """ 
    586         if (x != 0): 
    587             if dx ==None: 
    588                 dx= 0 
    589             err = -(dx)**2/x**2 
    590         else: 
    591             raise ValueError,"Cannot compute this error" 
    592          
    593         if math.fabs(err)>= math.fabs(x): 
    594             err= 0.9*x 
    595         return math.fabs(err) 
    596      
    597     def errOneOverSqrtX(self,x,y=None, dx=None,dy=None): 
    598         """ 
    599             Calculate error on 1/sqrt(x) 
    600         """ 
    601         if (x >0): 
    602             if dx==None: 
    603                 dx =0 
    604             err= -1/2*math.pow(x, -3/2)* dx 
    605             if math.fabs(err)>= math.fabs(x): 
    606                 err=0.9*x 
    607         else: 
    608             raise ValueError, "Cannot compute this error" 
    609          
    610         return math.fabs(err) 
    611      
    612                        
    613404    def onFitDisplay(self, plottable): 
    614405        """ 
    … …  
    624415        self.graph.delete(plottable) 
    625416       
    626          
    627       
    628          
     417     
    629418     
    630419class NoRepaintCanvas(FigureCanvasWxAgg): 

  • guitools/PropertyDialog.py

    r5789654 r831149e  
    4545        self.xvalue.SetValue("x") 
    4646        self.xvalue.Insert("x",0) 
    47         self.xvalue.Insert("Log(x)",1) 
    48         self.xvalue.Insert("x^(2)",2) 
     47        self.xvalue.Insert("x^(2)",1) 
     48        self.xvalue.Insert("log10(x)",2) 
     49         
    4950         
    5051        # scale value for y 
    51         self.yvalue.SetValue("Log(y)") 
     52        self.yvalue.SetValue("log10(y)") 
    5253        self.yvalue.Insert("y",0) 
    53         self.yvalue.Insert("Log(y)",1) 
    54         self.yvalue.Insert("y^(2)",2) 
    55         self.yvalue.Insert("1/y",3) 
     54        self.yvalue.Insert("1/y",1) 
     55        self.yvalue.Insert("ln(y)",2) 
     56        self.yvalue.Insert("y^(2)",3) 
    5657        self.yvalue.Insert("1/sqrt(y)",4) 
    57         self.yvalue.Insert("Log(y*x)",5) 
    58         self.yvalue.Insert("Log(y*x^(2))",6) 
     58        self.yvalue.Insert("log10(y)",5) 
     59        self.yvalue.Insert("ln(y*x)",6) 
     60        self.yvalue.Insert("ln(y*x^(2))",7) 
     61        self.yvalue.Insert("ln(y*x^(4))",8) 
    5962         
    6063        panel.SetSizer(sizer) 

  • guitools/fitDialog.py

    r106ef4d r831149e  
    77from plottables import Theory1D 
    88import math,pylab,fittings 
     9import transform 
     10 
     11 
    912class LinearFit(wx.Dialog): 
    1013    #def __init__(self, parent, id, title): 
    … …  
    3336        self.tcErrB = wx.TextCtrl(panel, -1,size=(120,20),style=wx.SIMPLE_BORDER) 
    3437        self.tcChi = wx.TextCtrl(panel, -1,size=(120,20),style=wx.SIMPLE_BORDER) 
    35         self.tcXmin = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
    36         self.tcXmax = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
     38        self.FXmin = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
     39        self.FXmax = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
     40        self.PXmin = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
     41        self.PXmax = wx.TextCtrl(panel,-1,size=(120,20),style=wx.SIMPLE_BORDER) 
    3742        self.btFit =wx.Button(panel,-1,'Fit',size=(120, 30)) 
    3843        self.btClose =wx.Button(panel, wx.ID_CANCEL,'Close',size=(90, 30) ) 
    … …  
    7782        sizer.Add(wx.StaticText(panel, -1, 'Xmax'),(iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    7883        iy += 1 
    79         ix = 1 
    80         sizer.Add(self.tcXmin, (iy, ix),(1,1),\ 
     84        ix = 0 
     85        sizer.Add(wx.StaticText(panel, -1, 'Plotted Range'),(iy, ix),(1,1),\ 
     86                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
     87        ix +=1 
     88        sizer.Add(self.PXmin, (iy, ix),(1,1),\ 
    8189                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    8290        ix += 2 
    83         sizer.Add(self.tcXmax, (iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     91        sizer.Add(self.PXmax, (iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     92        iy += 1 
     93        ix = 0 
     94        sizer.Add(wx.StaticText(panel, -1, 'Fit Range'),(iy, ix),(1,1),\ 
     95                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
     96        ix += 1 
     97        sizer.Add(self.FXmin, (iy, ix),(1,1),\ 
     98                   wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     99        ix += 2 
     100        sizer.Add(self.FXmax, (iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    84101        iy += 1 
    85102        ix = 1 
    … …  
    112129        self.tcErrB.SetLabel(str(0.0)) 
    113130        self.tcChi.SetLabel(str(0.0)) 
    114          
     131        if self.plottable.x !=[]: 
     132            self.mini =min(self.plottable.x) 
     133            self.maxi =max(self.plottable.x) 
     134            self.FXmin.SetLabel(str(self.mini)) 
     135            self.FXmax.SetLabel(str(self.maxi)) 
     136             
     137            self.PXmin.SetValue(str(self.mini)) 
     138            self.PXmax.SetValue(str(self.maxi)) 
     139            self.PXmin.Disable() 
     140            self.PXmax.Disable() 
    115141        
    116142         
    … …  
    131157         
    132158        #Check if the field of Fit Dialog contain values and use the x max and min of the user 
    133         xmin = self._checkVal(self.tcXmin.GetValue()) 
    134         xmax = self._checkVal(self.tcXmax.GetValue()) 
    135          
     159        xmin,xmax = self._checkVal(self.FXmin.GetValue(),self.FXmax.GetValue()) 
     160        
    136161        #store the values of View in x,y, dx,dy 
    137162        x,y,dx,dy=self.plottable.returnValuesOfView() 
    … …  
    141166        # Check if View contains a x array .we online fit when x exits 
    142167        # makes transformation for y as a line to fit 
    143         if x != []:                 
    144             if (xmin ==None)and (xmax == None): 
    145                 #Display the min and the max of x on fit dialog fields 
    146                 self.tcXmin.SetValue(str(min(x))) 
    147                 self.tcXmax.SetValue(str(max(x))) 
    148            
    149              
     168        if x != []:  
     169             
     170            xminView=self.floatTransform(xmin) 
     171            xmaxView=self.floatTransform(xmax) 
     172         
    150173            # Store the transformed values of view x, y,dy in variables  before the fit 
    151             if  self.ytrans == "Log(y)": 
     174            if  self.ytrans.lower() == "log10(y)": 
    152175                for y_i in y: 
    153                     tempy.append(math.log(y_i))  
     176                    tempy.append(math.log10(y_i))  
    154177            else: 
    155178                tempy = y 
    156                  
     179            if  self.xtrans.lower() == "log10(x)": 
     180                for x_i in x: 
     181                    tempx.append(math.log10(x_i))  
     182            else: 
     183                tempx = x 
     184                    
    157185            for y_i in y: 
    158186                dy = 1/y_i 
    … …  
    161189                tempdy.append(dy) 
    162190                    
    163              
    164             if  self.xtrans == "Log(x)": 
    165                 for x_i in x: 
    166                     tempx.append(math.log(x_i))  
    167             else: 
    168                 tempx = x 
    169                  
    170191            #Find the fitting parameters 
    171             if (xmin !=None and xmin >= min(tempx) ) and (xmax !=None and xmax <= max(tempx)):    
    172                 chisqr, out, cov = fittings.sansfit(self.model,  
    173                             [self.cstA, self.cstB],tempx, tempy,tempdy,xmin,xmax) 
    174             else: 
    175                 chisqr, out, cov = fittings.sansfit(self.model,  
    176                             [self.cstA, self.cstB],tempx, tempy,tempdy,min(tempx),max(tempx)) 
     192            print "X", tempx 
     193            print "Y", tempy 
     194            chisqr, out, cov = fittings.sansfit(self.model,  
     195                            [self.cstA, self.cstB],tempx, tempy,tempdy,xminView,xmaxView) 
    177196             
    178197            #Check that cov and out are iterable before displaying them 
    … …  
    192211            self.model.setParam('A', float(cstA)) 
    193212            self.model.setParam('B', float(cstB)) 
     213            print "this is constant A:",float(cstA) 
     214            tempx = [] 
    194215            tempy = [] 
    195216            y_model = 0.0 
    196              
    197             for j in range(len(x)):  
    198                     if (xmin !=None)and (xmax != None): 
    199                         if (x[j] > xmin and x[j] < xmax): 
    200                             y_model = self.model.run(x[j]) 
    201                     else: 
    202                         # x has a default value in case the user doesn't load data 
    203                         if self.xtrans == "Log(x)": 
    204                             y_model = self.model.run(math.log(x[j])) 
    205                         else: 
    206                             y_model = self.model.run(x[j]) 
     217            # load tempy with the minimum transformation 
     218            
     219            if self.xtrans == "log10(x)": 
     220                y_model = self.model.run(math.log10(xmin)) 
     221 
     222            else: 
     223                y_model = self.model.run(xminView) 
     224            tempx.append(xmin) 
     225             
     226            if self.ytrans == "log10(y)": 
     227                tempy.append(math.pow(10,y_model)) 
     228            else: 
     229                tempy.append(y_model) 
     230            #Load tempy with the value between xView min and xView max 
     231            #for j in range(len(x)):  
     232            #    if (x[j] > xminView and x[j] < xmaxView): 
     233            #        if self.xtrans == "log10(x)": 
     234            #            y_model = self.model.run(math.log10(x[j])) 
     235            #        else: 
     236            #            y_model = self.model.run(x[j]) 
     237                         
     238                         
     239            #        if self.ytrans == "log10(y)": 
     240            #            tempy.append(math.pow(10,y_model)) 
     241            #        else: 
     242            #            tempy.append(y_model) 
     243            #        tempx.append(x[j]) 
    207244                     
    208                     if self.ytrans == "Log(y)": 
    209                         tempy.append(math.exp(y_model)) 
    210                     else: 
    211                         tempy.append(y_model) 
    212                          
     245            # load tempy with the maximum transformation 
     246            if self.xtrans == "log10(x)": 
     247                y_model = self.model.run(math.log10(xmax)) 
     248                
     249            else: 
     250                y_model = self.model.run(xmaxView) 
     251            tempx.append(xmax) 
     252                 
     253            if self.ytrans == "log10(y)": 
     254                tempy.append(math.pow(10,y_model)) 
     255            else:  
     256                tempy.append(y_model) 
    213257            # Create new data plottable with result 
    214             self.file_data1.x =x  
    215             self.file_data1.y =[]   
     258            self.file_data1.x =[]  
     259            self.file_data1.y =[]  
     260            self.file_data1.x =tempx   
    216261            self.file_data1.y =tempy      
    217262            self.file_data1.dx=None 
    … …  
    240285        return self.file_data1 
    241286     
    242     def _checkVal(self,value): 
    243         """ 
    244                 Ensure that fields parameter contains a value  
    245                 before sending to fit in Plotter1D 
    246         """ 
    247         try: 
    248             param = float(value) 
    249         except: 
    250             param = None 
    251         return param 
     287    def _checkVal(self,usermin, usermax): 
     288        """ 
     289                Ensure that fields parameter contains a min and a max value  
     290                within x min and x max range 
     291        """ 
     292        if float(usermin) < float(usermax): 
     293            if float(usermin) >= float(self.mini) and float(usermin) < float(self.maxi): 
     294                self.FXmin.SetValue(str(usermin)) 
     295            else: 
     296                self.FXmin.SetValue(str(self.mini)) 
     297                 
     298            if float(usermax) > float(self.mini) and float(usermax) <= float(self.maxi): 
     299                self.FXmax.SetLabel(str(usermax)) 
     300            else: 
     301                self.FXmax.SetLabel(str(self.maxi)) 
     302                 
     303            mini =float(self.FXmin.GetValue()) 
     304            maxi =float(self.FXmax.GetValue()) 
     305             
     306            return mini, maxi 
     307    def floatTransform(self,x): 
     308        """ 
     309             transform a float.It is use to determine the x.View min and x.View max for values 
     310             not in x 
     311        """ 
     312        if ( self.xtrans=="x" ): 
     313            return transform.toX(x) 
     314         
     315        if ( self.xtrans=="x^(2)" ): 
     316            return transform.toX2(x) 
     317         
     318        if (self.xtrans=="log10(x)" ): 
     319            if x >0: 
     320                return math.log10(x) 
     321            else: 
     322                raise ValueError,"cannot compute log of a negative number" 
     323        
     324                 
    252325    
    253326if __name__ == "__main__":  

  • guitools/plottables.py

    r370e587 r831149e  
    409409         
    410410        return self.view.returnXview() 
    411          
    412          
     411    
    413412    class View: 
    414413        """ 
    … …  
    524523        def returnXview(self): 
    525524            return self.x,self.y,self.dx,self.dy 
    526             
    527       
     525         
     526        def returnValueOfView(self,i):  
     527            print"this is i:",i 
     528            if i in range(len(self.x)): 
     529                print self.x[i] 
     530                return self.x[i] 
     531 
    528532class Data1D(Plottable): 
    529533    """Data plottable: scatter plot of x,y with errors in x and y. 

  • guitools/requirements.txt

    r5aa3bbd r831149e  
    7878 This is a list the changes Steeve wants : 
    7979  
    80   1- Add curves : ln(y) in linear scale, ln(x^(4)*I) 
    81   2- Specify in the fitDialog if natural log or log base 10 
     80  1- [DONE] Add curves : ln(y) in linear scale, ln(x^(4)*I) 
     81   
     82  2- [DONE]Specify in the fitDialog if natural log or log base 10 
     83   
    8284  3- When fitting sphere.txt , logx --logy ,fitting is not correct 
     85   
    8386  4- the line to fit always is displayed from x min to max all the time even if xmin is changed 
    8487     or xmax is changed 
     88      
    8589  5- The fitting errors are too small (order of 10^(-7))for that case too,certainly wrong 
     90   
    8691  6- When to see errors bars appear when loading sphere.txt file.  
     92   
    8793  7- Add zoom in option when xmax and xmin(user) are entered. 
    88   8- Always want to know the initial value of xmin and xmax when opening the fitDialog.These values 
     94   
     95  8-[DONE] Always want to know the initial value of xmin and xmax when opening the fitDialog.These values 
    8996     should always be independant of the transformation 
     97      
    9098  9- the user should be able to add point to fit without knowing the exact range or guessing 
    9199                a range to fit. 
    … …  
    94102  1- I probably have to change the interface of the fitdialog, I would like to discuss  
    95103     it before proceeding 
    96    
     104        ALINA 
     105 1- Would like to change the y axis label display 
Note: See TracChangeset for help on using the changeset viewer.