Changeset 831149e in sasview for guitools/PlotPanel.py


Ignore:
Timestamp:
Apr 15, 2008 2:49:58 PM (16 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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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): 
Note: See TracChangeset for help on using the changeset viewer.