Changeset 1148 for SHX


Ignore:
Timestamp:
29.01.2016 16:39:36 (4 years ago)
Author:
klaus
Message:

many comments inserted; phases now on backing store bitmap; more magnitude entries; all components in magnify window

Location:
SHX/trunk/SeismicHandler
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • SHX/trunk/SeismicHandler/basics/analysispar.py

    r1146 r1148  
    201201        self.default_weight = weight 
    202202 
     203 
     204#------------------------------------------------------------------------------- 
     205 
     206 
     207class StationMagnitude: 
     208 
     209    def __init__( self, ml=None, mb=None, mS=None, mBB=None ): 
     210        self.ml = ml 
     211        self.mb = mb 
     212        self.mS = mS 
     213        self.mBB = mBB 
     214     
     215    def add( self, magtype, magvalue ): 
     216        if hasattr(self,magtype): 
     217            setattr( self, magtype, magvalue ) 
     218            return True 
     219        else: 
     220            return False 
     221     
     222    def clear( self, magtype ): 
     223        if hasattr(self,magtype): 
     224            setattr( self, magtype, None ) 
     225            return True 
     226        else: 
     227            return False 
     228     
     229    def get( self, magtype ): 
     230        if hasattr(self,magtype): 
     231            return getattr(self,magtype) 
     232        return None 
     233     
     234    def isempty( self ): 
     235        return (self.ml == None and self.mb == None \ 
     236            and self.mS == None and self.mBB == None) 
     237 
     238 
     239#------------------------------------------------------------------------------- 
     240 
     241 
     242class MagnitudeList: 
     243 
     244    """ 
     245    Store magnitudes for all stations. 
     246    """ 
     247 
     248    __metaclass__ = Singleton 
     249 
     250    def __init__( self ): 
     251        self.magndict = {} 
     252     
     253    def addStationMagnitude( self, station, magtype, magvalue ): 
     254        upstat = station.upper() 
     255        if upstat in self.magndict.keys(): 
     256            self.magndict[upstat].add( magtype, magvalue ) 
     257        else: 
     258            par = { magtype: magvalue } 
     259            self.magndict[upstat] = StationMagnitude( **par ) 
     260     
     261    def clearStationMagnitude( self, station, magtype ): 
     262        upstat = station.upper() 
     263        if upstat in self.magndict.keys(): 
     264            self.magndict[upstat].clear(magtype) 
     265            if self.magndict[upstat].isempty(): 
     266                del( self.magndict[upstat] ) 
     267     
     268    def clearMagnitude( self, magtype ): 
     269        for station in self.magndict.keys(): 
     270            self.clearStationMagnitude( station, magtype ) 
     271     
     272    def getStations( self ): 
     273        return self.magndict.keys() 
     274     
     275    def getMagnitudeTypes( self, station ): 
     276        upstat = station.upper() 
     277        mlist = [] 
     278        if upstat in self.magndict.keys(): 
     279            if self.magndict[upstat].ml != None: 
     280                mlist.append( 'ml' ) 
     281            if self.magndict[upstat].mb != None: 
     282                mlist.append( 'mb' ) 
     283            if self.magndict[upstat].mS != None: 
     284                mlist.append( 'mS' ) 
     285            if self.magndict[upstat].mBB != None: 
     286                mlist.append( 'mBB' ) 
     287        return mlist 
     288     
     289    def getStationMagnitude( self, station, magtype ): 
     290        upstat = station.upper() 
     291        if upstat in self.magndict.keys(): 
     292            return self.magndict[station].get(magtype) 
     293        return None 
     294     
     295    def meanMagnitude( self, magtype ): 
     296        mmag = 0. 
     297        mcnt = 0 
     298        for station in self.magndict.keys(): 
     299            m = self.magndict[station].get(magtype) 
     300            if m != None: 
     301                mmag += m 
     302                mcnt += 1 
     303        if mcnt > 0: 
     304            return (mmag/float(mcnt)) 
     305        else: 
     306            return None 
     307     
    203308 
    204309#------------------------------------------------------------------------------- 
     
    379484                    fromUTCDateTime(phase.picktime),phase.name, 
    380485                    phaselist.picktypeName(phase.picktype),phase.comp) ) 
     486        for station in maglist.getStations(): 
     487            for magtype in maglist.getMagnitudeTypes(station): 
     488                m = maglist.getStationMagnitude( station, magtype ) 
     489                fp.write( "@MAGNITUDE SET %s %s %g\n" % (magtype,station,m) ) 
    381490        fp.close() 
    382491     
     
    394503phaselist = PhaseList() 
    395504analysispar = AnalysisPar() 
    396  
     505maglist = MagnitudeList() 
     506 
  • SHX/trunk/SeismicHandler/commands/magnitude.py

    r1147 r1148  
    108108            if len(self.parameters) > 2: 
    109109                station = self.parameters[2] 
     110                # convert trace number to station, if trace number given 
     111                try: 
     112                    trcno = int( station ) 
     113                except: 
     114                    trcno == None 
     115                if trcno != None: 
     116                    try: 
     117                        trc = traces_from_list( "%d" % trcno )[0] 
     118                    except: 
     119                        return 
     120                    station = "%s.%s" % (trc.stats.network,trc.stats.station) 
    110121                maglist.clearStationMagnitude( station, magtype ) 
    111122            else: 
  • SHX/trunk/SeismicHandler/commands/theophase.py

    r1146 r1148  
    6868    legal_methods = { 
    6969        'local':  LocalTravelTime, 
    70         'iasp91': TaupiTravelTime, 
     70        'taupi': TaupiTravelTime, 
    7171    } 
    7272 
     
    111111        if methodname == 'local': 
    112112            distunit = 'km' 
    113         elif methodname == 'iasp91': 
     113        elif methodname == 'taupi': 
    114114            distunit = 'deg' 
    115115        else: 
     
    124124                except: 
    125125                    raise ShxError( "ttt: need vp1,vp2,vs1,vs2,d as floats" ) 
    126             elif modelname == 'iasp91': 
     126            elif modelname == 'taupi': 
    127127                model['modelname'] = self.qualfiers["MODEL"].lower() 
    128128            else: 
  • SHX/trunk/SeismicHandler/commands/ttt.py

    r1146 r1148  
    5353    legal_methods = { 
    5454        'local':  LocalTravelTime, 
    55         'iasp91': TaupiTravelTime, 
     55        'taupi': TaupiTravelTime, 
    5656    } 
    5757 
     
    8484                except: 
    8585                    raise ShxError( "ttt: need vp1,vp2,vs1,vs2,d as floats" ) 
    86             elif modelname == 'iasp91': 
     86            elif modelname == 'taupi': 
    8787                model['modelname'] = self.qualfiers["MODEL"].lower() 
    8888            else: 
  • SHX/trunk/SeismicHandler/modules/wx_.py

    r1146 r1148  
    5656    """ 
    5757    def __init__( self, parent ): 
     58        "magnifyCanvas: init method." 
    5859        wx.Panel.__init__( self, parent, 
    5960            style=wx.BORDER_SIMPLE|wx.NO_FULL_REPAINT_ON_RESIZE) 
     
    7879        self._mousedouble = None 
    7980        self._dragstarttime = None 
     81        self._s3_showalltraces = False 
     82        self._s3_origtrcname = None 
     83        self._s3_othertraces = [] 
    8084        self.SetBackgroundColour( "white" ) 
    8185        self.clearWindow() 
    8286     
    8387    def OnPaint( self, e ): 
     88        "magnifyCanvas: redraw event." 
    8489        if self._magn_bitmap: 
    8590            dc = wx.BufferedPaintDC(self, self._magn_bitmap) 
     91            #self._drawPicks() 
    8692     
    8793    def OnSize( self, e ): 
     94        "magnifyCanvas: resize event." 
    8895        self.pixwidth, self.pixheight = self.GetVirtualSize() 
    8996        self.refresh() 
    9097     
    9198    def OnMouseMotion(self, evt): 
     99        "magnifyCanvas: mouse motion event." 
    92100        if not self.trc: 
    93101            return 
     
    97105        if evt.LeftIsDown(): 
    98106            self._drawXorLine( x ) 
    99         # Put text instatus line of plotter window 
     107        # Put text in status line of plotter window 
    100108        stext = "%s - %g - %s - Z:%3.1f" % (fromUTCDateTime(abstime),reltime, 
    101109            self.trc.id,(self.trc.stats.endtime-self.trc.stats.starttime)) 
     
    109117 
    110118    def OnMouseLeftDown(self, evt): 
    111         "Left moune button pressed down." 
     119        "magnifyCanvas: Left moune button pressed down." 
    112120        x, y = evt.GetPositionTuple() 
    113121        abstime = self._fromScreenCoo( x,  mode='abs' ) 
     
    128136     
    129137    def OnMouseRightDown( self, evt ): 
     138        "magnifyCanvas: right mouse button pressed." 
    130139        x, y = evt.GetPositionTuple() 
    131140        self._dragstarttime = self._fromScreenCoo( x,  mode='abs' ) 
     
    133142 
    134143    def OnMouseRightUp( self, evt ): 
     144        "magnifyCanvas: right mouse button released." 
    135145        self._dragstarttime = None 
    136146        evt.Skip() 
    137147 
    138148    def OnMouseLeftUp(self, evt): 
    139         "Left mouse button released." 
     149        "magnifyCanvas: left mouse button released." 
    140150        if not self.trc: 
    141151            return 
     
    164174     
    165175    def OnMouseLeftDouble( self, evt ): 
     176        "magnifyCanvas: left double click." 
    166177        self._mousedouble = True 
    167178 
    168179    def OnMouseWheel(self, evt): 
     180        "magnifyCanvas: mouse wheel event." 
    169181        wheel = evt.GetWheelRotation() 
    170182        if wheel > 0: 
     
    175187     
    176188    def OnKeyPress( self, evt ): 
     189        "magnifyCanvas: key events do not work (i.e. this is never called)." 
    177190        print "dbg: key", dir(evt) 
    178191 
    179192    def refresh( self ): 
     193        "magnifyCanvas: redraw content of window." 
    180194        self._drawMagnifyTrace() 
    181195        self._drawPicks() 
    182196 
    183197    def _closePhase( self, abstime ): 
    184         "Return name and type of closest phase or None." 
     198        "magnifyCanvas: return name and type of closest phase or None." 
    185199        if not self.trc: 
    186200            return None 
     
    196210        return None 
    197211     
    198     def _drawMagnifyTrace( self ):         
     212    def _drawMagnifyTrace( self, clear=True, othertrace=None, yoffset=0., 
     213        color=(0,0,0) ):         
     214        "magnifyCanvas: does the drawing work." 
    199215        # Bitmap holding the final figure, canvas->DC drawing to this bitmap. 
    200216        if self.trc == None: 
     
    206222            self.clearWindow() 
    207223            return 
     224        if othertrace == None: 
     225            drawtrc = self.trc 
     226        else: 
     227            drawtrc = othertrace 
    208228        amplscale = 1./norm * self.pixheight/2. 
    209229        self._magn_bitmap = wx.EmptyBitmap(self.pixwidth, self.pixheight) 
    210230        mdc = wx.MemoryDC(self._magn_bitmap) 
    211231        mdc.SetBrush(wx.TRANSPARENT_BRUSH) 
    212         mdc.Clear() 
     232        if clear: 
     233            mdc.Clear() 
    213234        mdc.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL)) 
    214         mdc.SetPen(wx.Pen((0,0,0), 1)) 
     235        mdc.SetPen(wx.Pen(color, 1)) 
    215236        mdc.BeginDrawing() 
    216237        mdc.DrawLines( 
    217238            zip( 
    218                 np.linspace( 0., self.pixwidth, len(self.trc.data) ), 
    219                 self.trc.data*amplscale + self.pixheight/2 
     239                np.linspace( 0., self.pixwidth, len(drawtrc.data) ), 
     240                drawtrc.data*amplscale + self.pixheight/2 + yoffset 
    220241            ) 
    221242        ) 
     
    228249     
    229250    def _drawPicks( self ): 
     251        "magnifyCanvas: add picks to waveform." 
    230252        if self.trc == None: 
    231253            return 
     
    242264                ( phase.name, self._toScreenCoo(phase.picktime) ) 
    243265            ) 
    244         dc = wx.ClientDC(self) 
     266        dc = wx.MemoryDC(self._magn_bitmap)  # mdc 
     267        #dc = wx.ClientDC(self) 
    245268        dc.SetBrush(wx.TRANSPARENT_BRUSH) 
    246269        dc.SetFont( wx.Font( 8, wx.DEFAULT, wx.NORMAL, wx.NORMAL ) ) 
     
    257280                if pname != '_Mark_': 
    258281                    dc.DrawText(pname, xcoo + 2, ydn - 10) 
     282        del dc          # mdc 
     283        self.Refresh()  # mdc 
     284        self.Update()   # mdc 
    259285     
    260286    def _drawXorLine( self, xcoo=None ): 
    261         """Draws line in XOR mode. Deletes previous line. To only clear old 
     287        """ 
     288        magnifyCanvas: 
     289        Draws line in XOR mode. Deletes previous line. To only clear old 
    262290        element, pass None. 
    263291        Should also draw into backing store bitmap (self._bitmap). Now, 
     
    289317 
    290318    def magnifyTrace( self, trc, boxwidth=None, boxcenter=None, boxend=None ): 
     319        "magnifyCanvas: top level redraw routine for magnify content." 
    291320        if trc == None: 
    292321            self.clearWindow() 
     322        if self._s3_showalltraces: 
     323            s3_recent = self._s3_origtrcname 
     324            self._s3_origtrcname = "%s.%s.%s.%s" % (trc.stats.network, 
     325                trc.stats.station,trc.stats.location,trc.stats.channel) 
     326            if s3_recent != self._s3_origtrcname: 
     327                self._s3_othertraces = self._s3_findOtherTraces() 
    293328        self.pixwidth, self.pixheight = self.GetVirtualSize() 
    294329        self.pixel_duration = self._fromScreenCoo( 1, mode='rel' ) 
     
    313348        else: 
    314349            self.trc = trc 
    315         self._drawMagnifyTrace() 
     350        clearwdw = True 
     351        if self._s3_showalltraces and len(self._s3_othertraces) > 0: 
     352            self._s3_showOtherTraces() 
     353            clearwdw = False 
     354        self._drawMagnifyTrace( clearwdw ) 
    316355        self._drawPicks() 
    317356     
    318357    def clearWindow( self ): 
     358        "magnifyCanvas: clear window content." 
    319359        dc = wx.AutoBufferedPaintDCFactory(self) 
    320360        dc.Clear() 
     
    322362     
    323363    def _toScreenCoo( self, abstime ): 
     364        "magnifyCanvas: helper for coo transformation." 
    324365        if not self.trc or not self.pixwidth: 
    325366            return 0. 
     
    330371     
    331372    def _fromScreenCoo( self, xpix, mode='abs' ): 
     373        "magnifyCanvas: helper for coo transformation." 
    332374        if not self.trc or not self.pixwidth: 
    333375            return 0. 
     
    340382        else: 
    341383            return (self.trc.stats.starttime + reltime,reltime) 
    342          
     384     
     385    def _s3_findOtherTraces( self ): 
     386        "magnifyCanvas: find other components of main trace." 
     387        tlist = [] 
     388        for trc in traces_from_list('all'): 
     389            sname = "%s.%s.%s.%s" % (trc.stats.network, 
     390                trc.stats.station,trc.stats.location,trc.stats.channel) 
     391            if sname == self._s3_origtrcname: 
     392                # not the same trace again 
     393                continue 
     394            # take away last char (component) 
     395            tname = self._s3_origtrcname[:-1] 
     396            if sname.startswith(tname): 
     397                tlist.append( trc ) 
     398        return tlist 
     399     
     400    def _s3_showOtherTraces( self ): 
     401        """ 
     402        magnifyCanvas: 
     403        show other components of main traces using plot method 
     404        _drawMagnifyTrace. 
     405        """ 
     406        yoffset = -self.pixheight/5 
     407        ystep = 2*self.pixheight/5 
     408        clearwdw = True 
     409        for trc in self._s3_othertraces: 
     410            otrc = trc.slice(self.trc.stats.starttime,self.trc.stats.endtime) 
     411            if len(otrc) < 2: 
     412                print "dbg: s3: short other trace" 
     413                continue 
     414            if abs(otrc.stats.starttime-self.trc.stats.starttime) \ 
     415                > self.trc.stats.delta: 
     416                print "dbg: s3: other trace stange start time" 
     417                continue 
     418            self._drawMagnifyTrace( clearwdw, otrc, yoffset, color=(200,200,200) ) 
     419            yoffset += ystep 
     420            clearwdw = False 
     421     
     422    def toggleShowAllTraces( self ): 
     423        "magnifyCanvas: toggle show-all-traces flag. Called from menu." 
     424        if self._s3_showalltraces: 
     425            self._s3_showalltraces = False 
     426            self._s3_origtrcname = None 
     427            self._s3_othertraces = [] 
     428        else: 
     429            self._s3_showalltraces = True 
    343430         
    344431 
     
    350437    #@timeit 
    351438    def __init__(self, parent, fnames=[]): 
     439        "Trace canvas init method." 
    352440        SP.ScrolledPanel.__init__(self, parent, 
    353441            style=wx.BORDER_SIMPLE|wx.NO_FULL_REPAINT_ON_RESIZE) 
     
    389477 
    390478        def disable_event(*pargs,**kwargs): 
     479            "traceCanvas: from some website." 
    391480            pass # the sauce, please 
    392481 
     
    420509    def __runtime_changer(self, name, value): 
    421510        """ 
     511        traceCanvas: 
    422512        Helper method for acting on certain runtime events. Called via message 
    423513        system. 
     
    443533     
    444534    def closePhase( self, trace, abstime ): 
    445         "Return name and type of closest phase or None." 
     535        "traceCanvas: Return name and type of closest phase or None." 
    446536        phaselist = PhaseList() 
    447537        if not self.pixel_duration: 
     
    455545        return None 
    456546     
    457     def _drawXor( self, mode, coo=(None,None,None,None) ): 
    458         """Draws line (len(coo)==2) or rectangle (len(coo) == 4) in XOR mode. 
     547    def _drawXor( self, mode, coo=(None,None,None,None), dc=None ): 
     548        """ 
     549        traceCanvas: 
     550        Draws line (len(coo)==2) or rectangle (len(coo) == 4) in XOR mode. 
    459551        Deletes previous line/rectangle. To only clear old element, pass 
    460552        None-tuples. 
     
    475567        else: 
    476568            size = 2 
    477         dc = wx.ClientDC(self) 
     569        if dc == None: 
     570            dc = wx.ClientDC(self) 
    478571        dc.SetLogicalFunction( wx.XOR ) 
    479572        dc.SetPen( wx.Pen(color,size,wx.SOLID) ) 
     
    503596    # event processing 
    504597    def OnMouseWheel(self, evt): 
     598        "traceCanvas: mouse wheel callback." 
    505599        maxwheelpos = 10 
    506600        wheel = evt.GetWheelRotation() 
     
    518612 
    519613    def OnKeyDown(self, evt): 
     614        "traceCanvas: key event doesn't work, i.e. this is never called." 
    520615        print "key" 
    521616        kc = evt.GetKeyCode() 
     
    525620 
    526621    def OnMouseLeftDouble(self, evt): 
     622        "traceCanvas: left double click." 
    527623        trace, tracetime = self.ScreenToTraceAndTime(*(evt.GetPositionTuple())) 
    528624        if trace: 
     
    538634 
    539635    def OnMouseRightDouble(self, evt): 
     636        "traceCanvas: right double click." 
    540637        print "dbg: right double click" 
    541638        self.zoomwdwwidth = 0. 
     
    543640 
    544641    def OnMouseLeftDown(self, evt): 
     642        "traceCanvas: press left mouse button." 
    545643        self._captureMouse(evt) 
    546644        trace, tracetime = self.ScreenToTraceAndTime(*(evt.GetPositionTuple())) 
     
    559657                if plotter.magnify: 
    560658                    plotter.magnify.canvas.refresh() 
    561             self._drawPicksAndZoom() 
     659            self._drawPicksM() 
    562660        evt.Skip() 
    563661 
    564662    def OnMouseRightDown(self, evt): 
     663        "traceCanvas: press right mouse button callback." 
    565664        self._captureMouse(evt) 
    566665        if self.zoomwdwwidth: 
     
    579678    def OnMouseMotion(self, evt): 
    580679        """ 
    581         Mouse motion. 
     680        traceCanvas: Mouse motion. 
    582681        """ 
    583682 
     
    656755    def OnMouseRightUp(self, evt): 
    657756        """ 
    658         Release of right mouse button. 
     757        traceCanvas: Release of right mouse button. 
    659758        """ 
    660759        if self.HasCapture(): 
     
    687786            self.ZoomWindow = [trace, start, end] 
    688787            self.dragStart = None 
    689             self._drawPicksAndZoom() 
     788            self._drawZoomWindow()  #?? 
    690789            if plotter and trace: 
    691790                # store relative times for possible menu call to stw. 
     
    702801    def OnMouseLeftUp(self, evt): 
    703802        """ 
    704         Release of left mouse button. 
     803        traceCanvas: Release of left mouse button. 
    705804        """ 
    706805        if self.HasCapture(): 
     
    750849    def OnScroll(self, evt): 
    751850        """ 
    752         Update scroll offset. 
     851        traceCanvas: Update scroll offset. Event disabled. 
    753852        """ 
    754853        print "dbg: on scroll" 
     
    764863    def OnIdle(self, evt): 
    765864        """ 
    766         Idle processing. Redraw is done here. 
     865        traceCanvas: idle processing. Redraw is done here. 
    767866        """ 
    768867        if self.refresh: 
     
    772871            self._resetTimeRange() 
    773872            self._drawTraces() 
    774             self._drawPicksAndZoom() 
     873            self._drawPicksM() 
     874            self._drawZoomWindow() 
    775875            if plotter.magnify: 
    776876                plotter.magnify.canvas.refresh() 
     
    780880    def _set_modes(self, name, mode): 
    781881        """ 
     882        traceCanvas: 
    782883        Method for altering the selection mode. Intended to be called from 
    783884        other threads using "CallAfter". 
     
    787888    def OnSize(self, evt, renewOverlay=False): 
    788889        """ 
    789         Called if redraw is requested. 
     890        traceCanvas: Called if redraw is requested. 
    790891 
    791892        Just set flag for redraw - execution triggered from IDLE event. 
     
    802903     
    803904    def OnPaint( self, evt ): 
     905        "traceCnvas: redraw event." 
    804906        if self._bitmap: 
    805907            dc = wx.BufferedPaintDC(self, self._bitmap) 
     
    808910    def OnNotifyTimeAxis(self, orientation): 
    809911        """ 
     912        traceCanvas: 
    810913        Handle changes of time axis mode (absolute vs. relative time 
    811914        axis). 
     
    819922    def OnNotifyTraceOrder(self, order): 
    820923        """ 
     924        traceCanvas: 
    821925        Handle changes of trace plotting mode (horizontal vs. vertical 
    822926        modes). 
     
    836940    def OnNotifyHeight(self, height): 
    837941        """ 
    838         Handle changes of display height. 
     942        traceCanvas: handle changes of display height. 
    839943        """ 
    840944        if self.traceOrder in [0, 1]: 
     
    850954 
    851955    def OnNotifyPhaseName(self, name): 
     956        "traceCanvas: ?" 
    852957        self.phasename = name 
    853958 
     
    856961    def ScreenToRelativeTime(self, x, y): 
    857962        """ 
    858         Returns relative time inside screen. 
     963        traceCanvas: Returns relative time inside screen. 
    859964        """ 
    860965        x, y = self.CalcUnscrolledPosition((x,y)) 
     
    9001005    def ScreenToTraceAndTime(self, x, y): 
    9011006        """ 
     1007        traceCanvas: 
    9021008        Returns trace instance and time code derived from cursor 
    9031009        position inside graphical panel. 
     
    9861092    def TraceAndTimeToScreen(self, trace, time): 
    9871093        """ 
     1094        traceCanvas: 
    9881095        Return x, y from given trace (midpoint) and time code. 
    9891096        """ 
     
    10341141    #@timeit 
    10351142    def _setup(self): 
     1143        "traceCanvas: helper routine." 
    10361144        w, h = self.GetClientSize() 
    10371145        if self.traceOrder in [0, 1]: 
     
    10481156    #@timeit 
    10491157    def _captureMouse(self, evt): 
     1158        "traceCanvas: helper." 
    10501159        self.CaptureMouse() 
    10511160 
     
    10601169    #@timeit 
    10611170    def _releaseMouse(self, evt): 
     1171        "traceCanvas: helper." 
    10621172        self.ReleaseMouse() 
    10631173 
     
    10721182 
    10731183    #@timeit 
    1074     def _drawPicksAndZoom(self): 
    1075         """ 
    1076         Draw picks. 
     1184    def _drawPicksM(self): 
     1185        """ 
     1186        traceCanvas: draw picks. 
    10771187        """ 
    10781188        phaselist = PhaseList() 
     
    10931203            return 
    10941204 
    1095         dc = wx.ClientDC(self) 
    1096         # odc disables redraw 
    1097         #odc = wx.DCOverlay(self.overlay_picks, dc) 
    1098         #odc.Clear() 
     1205        dc = wx.MemoryDC(self._bitmap)   # mdc 
     1206        #dc = wx.ClientDC(self) 
    10991207        dc.SetBrush(wx.TRANSPARENT_BRUSH) 
    11001208        dc.SetFont( wx.Font( 8, wx.DEFAULT, wx.NORMAL, wx.NORMAL ) ) 
     
    11211229                        dc.DrawRotatedText(pick[0], pick[1][0] - th2 + 2, 
    11221230                                                            pick[1][1] - 2, 90) 
    1123         #del odc 
    1124  
     1231        del dc          # mdc 
     1232        self.Refresh()  # mdc 
     1233        self.Update()   # mdc 
     1234 
     1235    def _drawZoomWindow( self ): 
    11251236        #draw zoom window 
    11261237        if self.ZoomWindow: 
     
    11441255 
    11451256    def _drawSinglePick( self, trace, tracetime, color=None ): 
    1146         "Just for quick respomse to the user." 
     1257        "traceCanvas: Just for quick response to the user." 
    11471258        pname = self.last_defined_phase 
    11481259        if not pname: 
     
    11641275    def _drawTraces(self): 
    11651276        """ 
     1277        traceCanvas: 
    11661278        Do the real plotting of waveforms including station text and 
    11671279        time scale. 
     
    15141626 
    15151627    def prepImage( self, trc, width, height, timewindow, zoom, norm ): 
    1516         "Return polygon ready for plotting via wx." 
     1628        "traceCanvas: return polygon ready for plotting via wx." 
    15171629 
    15181630        windowstart, windowend = timewindow 
     
    15561668    def save_shot(self, dc): 
    15571669        """ 
    1558         Save PNG screen shot (PS later) 
     1670        traceCanvas: Save PNG screen shot (PS later) 
    15591671        """ 
    15601672        size = dc.Size 
     
    15721684    #@timeit 
    15731685    def niceNumbers( self, start, end, pixwidth, parts ): 
    1574         "2150 surf min" 
     1686        "traceCanvas: nice numbers for time axis." 
    15751687        num = (end - start) / parts 
    15761688        pixscaling = pixwidth / (end-start) 
     
    15951707    @staticmethod 
    15961708    def _debug(*args): 
     1709        "traceCanvas: helper." 
    15971710        log_message('debug.wx', " ".join([str(i) for i in args])) 
    15981711        #print "dbg:", " ".join([str(i) for i in args]) 
     
    16011714    def _resetTimeRange(self, **kwargs): 
    16021715        """ 
     1716        traceCanvas: 
    16031717        Gather information about traces. Called on redraw (at idle state). 
    16041718        """ 
     
    16551769     
    16561770    #@timeit 
    1657     def __zoombox(self, start, end, midpoint, color="DARKORANGE", size=1): 
     1771    def __zoombox(self, start, end, midpoint, color="DARKORANGE", size=1, 
     1772        dc=None): 
     1773        "traceCanvas: draw zoom box in XOR mode." 
    16581774        if start == None: 
    1659             self._drawXor( 'rect', (None,None,None,None) ) 
     1775            self._drawXor( 'rect', (None,None,None,None), dc ) 
    16601776            return 
    16611777        if midpoint == None: 
     
    16671783        if self.traceOrder in [0, 1]: 
    16681784            self._drawXor( 'rect', (start[0], offset + th2 * marginfactor, 
    1669                 end[0] - start[0], th2 * mf2) ) 
     1785                end[0] - start[0], th2 * mf2), dc ) 
    16701786        elif self.traceOrder in [2, 3]: 
    16711787            self._drawXor( 'rect', (offset + th2 * marginfactor, start[1], 
    1672                 th2 * mf2, end[1] - start[1]) ) 
     1788                th2 * mf2, end[1] - start[1]), dc ) 
    16731789     
    16741790    def moveZoomWindow( self, direction, span=None ): 
     1791        "traceCanvas: move zoom window." 
    16751792        if not self.ZoomWindow: 
    16761793            return 
     
    17061823            return 
    17071824        self.ZoomWindow = trace, start, end 
    1708         self._drawPicksAndZoom() 
     1825        plotter.setZoomWindow( trace.index(True), _absToRelTime(trace,start), 
     1826            _absToRelTime(trace,end) ) 
     1827        self._drawZoomWindow() 
    17091828        plotter.magnify.canvas.magnifyTrace( trace, boxwidth=boxwidth, 
    17101829            boxend=end ) 
     
    17141833 
    17151834    def __init__( self, parent, title, size=None, position=None ): 
     1835        "magnifyWindow: init method." 
    17161836        if size == None or position == None: 
    17171837            px, py = plotter.GetPosition() 
     
    17441864    """ 
    17451865    def __init__(self, parent, title, size=(640,280), position=(50,100)): 
     1866        "plotterWindow: init method." 
    17461867        # save instance for external access 
    17471868        global plotter 
     
    17721893     
    17731894    def openMagnifyWindow( self, e ): 
     1895        "plotterWindow: open magnify window." 
    17741896        self.magnify = magnifyWindow( self, 'SHX magnify' ) 
    17751897     
    17761898    def showMessage( self, msg, error=False ): 
     1899        "plotterWindow: show message in a dialog." 
    17771900        mode = wx.OK 
    17781901        if error: 
     
    17821905        dlg.Destroy() 
    17831906         
     1907    def redraw(self): 
     1908        "plotterWindow: redraw procedure." 
     1909        self.canvas.OnSize(None) 
     1910     
     1911    def setZoomWindow( self, trace, start, end ): 
     1912        "plotterWindow: get new zoom window (called from other class instances." 
     1913        self._seltrace = trace 
     1914        self._zoomwdw = (start,end) 
     1915 
    17841916    def addMenuEntries( self ): 
     1917        "plotterWindow: definition of menu entries." 
    17851918        menubar = wx.MenuBar() 
    17861919        menubar.SetBackgroundColour( shxcolor2 ) 
     
    18381971            'Scroll traces down. Use mouse wheel', self.OnTraceScrollDown ) 
    18391972        self._menuitems['TraceScrollDown'] = m 
     1973        self.addEntry( windowMenu, 'Show All Components in Magnify\t3', 
     1974            'Show other components in magnify window.', 
     1975            self.OnShowAllInMagnify ) 
    18401976        windowMenu.AppendSeparator() 
    18411977        self.addEntry( windowMenu, '&Norm All/Single\tCtrl+N', 
     
    19092045        self.addEntry( eventsMenu, 'Plot Location', 
    19102046            'Simple map with stations and epicenter', self.OnPlotLocation ) 
     2047        # phase menu 
    19112048        phaseMenu = wx.Menu() 
    19122049        self.addEntry( phaseMenu, 'Pg\tg', 
     
    19542091        self.addEntry( phaseMenu, 'Delete all Theo Phases', 
    19552092            'Delete all theoretical phases', self.OnDeleteTheoPhase ) 
     2093        # magnitude menu 
     2094        magnMenu = wx.Menu() 
     2095        self.addEntry( magnMenu, 'ml on all Trc. (analytic)', 
     2096            'Computes magnitude ml around picked phases at all traces up to selected', 
     2097            self.OnMagnMlAnalytic ) 
     2098        self.addEntry( magnMenu, 'ml on single Trc. (analytic)', 
     2099            'Computes magnitude ml within selection window', 
     2100            self.OnMagnMlAnalyticSingle ) 
     2101        self.addEntry( magnMenu, 'ml Delete all', 
     2102            'Deletes all ml magnitudes', self.OnMagnMlDeleteAll ) 
     2103        self.addEntry( magnMenu, 'ml Delete selected', 
     2104            'Deletes magnitude ml at selected trace', 
     2105            self.OnMagnMlDeleteSingle ) 
     2106        self.addEntry( magnMenu, 'ml Plot magnitudes', 
     2107            'Create and show a magnitude vs distance plot.', self.OnMagnMlPlot ) 
    19562108        # control menu 
    19572109        controlMenu = wx.Menu() 
     
    19732125        self.addEntry( controlMenu, 'Open Magnify Window', 
    19742126            'Open magnification window for traces', self.OnOpenMagnify ) 
     2127        self.addEntry( controlMenu, 'Refresh', 
     2128            'Refresh display', self.OnUserRefresh ) 
    19752129        # test menu 
    19762130        testMenu = wx.Menu() 
     
    19872141        menubar.Append( eventsMenu, 'Events' ) 
    19882142        menubar.Append( phaseMenu, 'Phases' ) 
     2143        menubar.Append( magnMenu, 'Magnitude' ) 
    19892144        menubar.Append( controlMenu, 'Control' ) 
    19902145        menubar.Append( testMenu, 'Test' ) 
     
    19952150        self.Centre() 
    19962151     
    1997     def addEntry( self, menutitle, entrytext, entrydescr, callback, accel=None ): 
     2152    def addEntry( self, menutitle, entrytext, entrydescr, callback, 
     2153        accel=None ): 
     2154        "plotterWindow: method to add a menu entry." 
    19982155        #self.menu_entry_id += 1 
    19992156        #qmi = wx.MenuItem( menutitle, self.menu_entry_id, entrytext, 
     
    20102167 
    20112168    def OnQuit( self, e ): 
     2169        "plotterWindow: file menu entry." 
    20122170        # Cannot quit SHX, _sendShCommand waits for command to be executed 
    20132171        # i.e. no way to terminate wx smoothly. Quit SHX after Close also not 
     
    20172175     
    20182176    def OnNorm( self, e ): 
     2177        "plotterWindow: display menu entry." 
    20192178        if self.flag_norm: 
    20202179            _sendShCommand( 'norm aw' ) 
     
    20242183 
    20252184    def OnOverlappingTraces( self, e ): 
     2185        "plotterWindow: traces menu entry." 
    20262186        if self.flag_overlap: 
    20272187            _sendShCommand( 'fct overlapping_traces false' ) 
     
    20312191 
    20322192    def OnDemean( self, e ): 
     2193        "plotterWindow: traces menu entry." 
    20332194        _sendShCommand( 'demean all' ) 
    20342195     
    20352196    def OnDeleteTrace( self, e ): 
     2197        "plotterWindow: traces menu entry." 
    20362198        if self._seltrace == None: 
    20372199            self.showMessage( "no trace selected" ) 
     
    20402202     
    20412203    def OnDeleteStation( self, e ): 
     2204        "plotterWindow: traces menu entry." 
    20422205        if self._seltrace == None: 
    20432206            self.showMessage( "no trace selected" ) 
     
    20512214 
    20522215    def OnDeleteTraceAndAbove( self, e ): 
     2216        "plotterWindow: traces menu entry." 
    20532217        if self._seltrace == None: 
    20542218            self.showMessage( "no trace selected" ) 
     
    20572221     
    20582222    def OnSpectrogram( self, e ): 
     2223        "plotterWindow: traces menu entry." 
    20592224        if self._seltrace == None: 
    20602225            self.showMessage( "no trace selected" ) 
     
    20722237 
    20732238    def OnTest1( self, e ): 
     2239        "plotterWindow: test menu entry." 
    20742240        _sendShCommand( 'fdsnws gr * * bhz 7-aug-15_00:16:30 420' ) 
    20752241 
    20762242    def OnTest2( self, e ): 
     2243        "plotterWindow: test menu entry." 
    20772244        _sendShCommand( 'fdsnws sx,th * * bhz 7-aug-15_00:16:30 420' ) 
    20782245 
    20792246    def OnSetTimeWindow( self, e ): 
     2247        "plotterWindow: display menu entry." 
    20802248        _sendShCommand( 'stw %g %g' % self._zoomwdw ) 
    20812249 
    20822250    def OnDelTimeWindow( self, e ): 
     2251        "plotterWindow: display menu entry." 
    20832252        _sendShCommand( 'dtw' ) 
    20842253 
    20852254    def OnMoveZoomRight( self, e ): 
     2255        "plotterWindow: display menu entry." 
    20862256        plotter.canvas.moveZoomWindow( 'right' ) 
    20872257 
    20882258    def OnMoveZoomLeft( self, e ): 
     2259        "plotterWindow: display menu entry." 
    20892260        plotter.canvas.moveZoomWindow( 'left' ) 
    20902261 
    20912262    def OnMoveZoomUp( self, e ): 
     2263        "plotterWindow: display menu entry." 
    20922264        plotter.canvas.moveZoomWindow( 'up' ) 
    20932265 
    20942266    def OnMoveZoomDown( self, e ): 
     2267        "plotterWindow: display menu entry." 
    20952268        plotter.canvas.moveZoomWindow( 'down' ) 
    20962269 
    20972270    def OnAmplZoomUp( self, e ): 
     2271        "plotterWindow: display menu entry." 
    20982272        _sendShCommand( "zoom/rel all 2" ) 
    20992273 
    21002274    def OnAmplZoomDown( self, e ): 
     2275        "plotterWindow: display menu entry." 
    21012276        _sendShCommand( "zoom/rel all 0.5" ) 
    21022277 
    21032278    def OnTraceScrollOn( self, e ): 
     2279        "plotterWindow: display menu entry." 
    21042280        global displayselect 
    21052281        displayselect = (1,21) 
     
    21112287 
    21122288    def OnTraceScrollOff( self, e ): 
     2289        "plotterWindow: display menu entry." 
    21132290        global displayselect 
    21142291        displayselect = None 
     
    21202297         
    21212298    def OnTraceScrollUp( self, e ): 
     2299        "plotterWindow: display menu entry." 
    21222300        _scrollTraces( 'up' ) 
    21232301 
    21242302    def OnTraceScrollDown( self, e ): 
     2303        "plotterWindow: display menu entry." 
    21252304        _scrollTraces( 'down' ) 
    21262305 
     2306    def OnShowAllInMagnify( self, e ): 
     2307        "plotterWindow: display menu entry." 
     2308        plotter.magnify.canvas.toggleShowAllTraces() 
     2309 
    21272310    def OnReadDataFile( self, e ): 
    2128         "Read one or more data files." 
     2311        "plotterWindow: file menu entry,  read one or more data files." 
    21292312        style = wx.FD_OPEN | wx.FD_FILE_MUST_EXIST 
    21302313        dlg = wx.FileDialog( self, "Select Data File", defaultDir=os.getcwd(), 
     
    21412324     
    21422325    def OnWriteDataFile( self, e ): 
    2143         "Writes all traces to file." 
     2326        "plotterWindow: file menue entry, writes all traces to file." 
    21442327        legal_formats = ('mseed','q','gse','gse2','sac') 
    21452328        style = wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT 
     
    21612344     
    21622345    def OnReadFdsnStations( self, e ): 
     2346        "plotterWindow: file menu entry." 
    21632347        ap = AnalysisPar() 
    21642348        cmd = "fdsnws %s %s %s %s %s %s /addr=%s" % ( 
     
    21762360 
    21772361    def OnReadFdsnCircle( self, e ): 
     2362        "plotterWindow: file menu entry." 
    21782363        ap = AnalysisPar() 
    21792364        cmd = "fdsnws %s,%s,%s * * %s %s %s /addr=%s" % ( 
     
    21912376     
    21922377    def OnCompleteMeta( self, e ): 
     2378        "plotterWindow: file menu entry." 
    21932379        ap = AnalysisPar() 
    21942380        _sendShCommand( 
     
    21972383 
    21982384    def OnSortByDistance( self, e ): 
     2385        "plotterWindow: traces menu entry." 
    21992386        ap = AnalysisPar() 
    22002387        lat = ap.getValueAsString( 'epi_latitude' ) 
     
    22062393     
    22072394    def OnFK( self, e ): 
     2395        "plotterWindow: array menu entry." 
    22082396        if not self._zoomwdw: 
    22092397            return 
     
    22192407     
    22202408    def OnFKAutoFreq( self, e ): 
     2409        "plotterWindow: array menu entry." 
    22212410        if not self._zoomwdw: 
    22222411            return 
     
    22302419        _sendShCommand( cmd ) 
    22312420    def OnBeam( self, e ): 
     2421        "plotterWindow: menu entry." 
    22322422        if self.flag_beam: 
    22332423            _sendShCommand( "shx_menu_delbeam" ) 
     
    22372427     
    22382428    def OnSimulateWoodAnderson( self, e ): 
     2429        "plotterWindow: filter menu entry." 
    22392430        _sendShCommand( 'shx_menu_simulate wood-anderson ;; 5.' ) 
    22402431 
    22412432    def OnSimulateWoodAnderson1Hz( self, e ): 
     2433        "plotterWindow: filter menu entry." 
    22422434        _sendShCommand( 'shx_menu_simulate wood-anderson 1.0 5.' ) 
    22432435 
    22442436    def OnSimulateWWSSNSP( self, e ): 
     2437        "plotterWindow: filter menu entry." 
    22452438        _sendShCommand( 'shx_menu_simulate wwssn-sp ;; 5.' ) 
    22462439 
    22472440    def OnSimulateWWSSNLP( self, e ): 
     2441        "plotterWindow: filter menu entry." 
    22482442        _sendShCommand( 'shx_menu_simulate wwssn-lp ;; 20.' ) 
    22492443 
    22502444    def OnSimulateLRSMSP( self, e ): 
     2445        "plotterWindow: filter menu entry." 
    22512446        _sendShCommand( 'shx_menu_simulate lrsm-sp ;; 5.' ) 
    22522447 
    22532448    def OnSimulateLRSMLP( self, e ): 
     2449        "plotterWindow: filter menu entry." 
    22542450        _sendShCommand( 'shx_menu_simulate lrsm-lp ;; 20.' ) 
    22552451 
    22562452    def OnSimulateKIRNOS( self, e ): 
     2453        "plotterWindow: filter menu entry." 
    22572454        _sendShCommand( 'shx_menu_simulate kirnos ;; 20' ) 
    22582455 
    22592456    def OnSimulateSROLP( self, e ): 
     2457        "plotterWindow: filter menu entry." 
    22602458        _sendShCommand( 'shx_menu_simulate sro-lp ;; 30.' ) 
    22612459 
    22622460    def OnFilterBP_1_8( self, e ): 
     2461        "plotterWindow: filter menu entry." 
    22632462        _sendShCommand( 'shx_menu_filter bp_1hz_8hz_4 5.' ) 
    22642463 
    22652464    def OnSimulateUndo( self, e ): 
     2465        "plotterWindow: filter menu entry." 
    22662466        _sendShCommand( 'shx_menu_simulate undo' ) 
    22672467     
    22682468    def OnOpenParams( self, e ): 
     2469        "plotterWindow: control menu entry." 
    22692470        self.pardialog = ParamDialog( self ) 
    22702471        self.pardialog.Show() 
     
    22722473     
    22732474    def OnOpenMagnify( self, e ): 
     2475        "plotterWindow: control menu entry." 
    22742476        plotter.openMagnifyWindow(None) 
     2477     
     2478    def OnUserRefresh( self, e ): 
     2479        self.redraw() 
    22752480         
    22762481    def OnGetEventlist( self, e ): 
     2482        "plotterWindow: events menu entry." 
    22772483        _sendShCommand( 'shx_menu_get_eventlist' ) 
    22782484 
    22792485    def OnNextEvent( self, e ): 
     2486        "plotterWindow: events menu entry." 
    22802487        _sendShCommand( 'shx_menu_next_event;;' ) 
    22812488 
    22822489    def OnPrevEvent( self, e ): 
     2490        "plotterWindow: events menu entry." 
    22832491        _sendShCommand( 'shx_menu_next_event -1' ) 
    22842492     
    22852493    def OnLocateEvent( self, e ): 
     2494        "plotterWindow: events menu entry." 
    22862495        _sendShCommand( 'locate shxvar /showresult' ) 
    22872496         
    22882497    def OnPlotLocation( self, e ): 
     2498        "plotterWindow: events menu entry." 
    22892499        ap = AnalysisPar() 
    22902500        lat = ap.getValue( 'epi_latitude' ) 
     
    22982508         
    22992509    def OnSaveTracesAndParamsQuick( self, e ): 
     2510        "plotterWindow: control menu entry." 
    23002511        sloutfile = 'TRACES_PARAMS_RECOVER.SHC' 
    23012512        cmd = "param savetraces %s\n" % sloutfile\ 
     
    23042515     
    23052516    def OnSaveTracesAndParams( self, e ): 
     2517        "plotterWindow: control menu entry." 
    23062518        style = wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT 
    23072519        dlg = wx.FileDialog( self, "Select Save File", defaultDir=os.getcwd(), 
     
    23192531     
    23202532    def OnRecoverTracesAndParamsQuick( self, e ): 
     2533        "plotterWindow: control menu entry." 
    23212534        _sendShCommand( 'TRACES_PARAMS_RECOVER' ) 
    23222535     
    23232536    def OnRecoverTracesAndParams( self, e ): 
     2537        "plotterWindow: control menu entry." 
    23242538        style = wx.FD_OPEN | wx.FD_FILE_MUST_EXIST 
    23252539        dlg = wx.FileDialog( self, "Select Recovery File", 
     
    23372551 
    23382552    def OnSetPhase_Pg( self, e ): 
     2553        "plotterWindow: phase menu entry." 
    23392554        _sendShCommand( "@PHASE DEFAULT_PHASE Pg" ) 
    23402555    def OnSetPhase_Pn( self, e ): 
     2556        "plotterWindow: phase menu entry." 
    23412557        _sendShCommand( "@PHASE DEFAULT_PHASE Pn" ) 
    23422558    def OnSetPhase_Sg( self, e ): 
     2559        "plotterWindow: phase menu entry." 
    23432560        _sendShCommand( "@PHASE DEFAULT_PHASE Sg" ) 
    23442561    def OnSetPhase_Sn( self, e ): 
     2562        "plotterWindow: phase menu entry." 
    23452563        _sendShCommand( "@PHASE DEFAULT_PHASE Sn" ) 
    23462564    def OnSetPhase_P( self, e ): 
     2565        "plotterWindow: phase menu entry." 
    23472566        _sendShCommand( "@PHASE DEFAULT_PHASE P" ) 
    23482567    def OnSetPhase_pP( self, e ): 
     2568        "plotterWindow: phase menu entry." 
    23492569        _sendShCommand( "@PHASE DEFAULT_PHASE pP" ) 
    23502570    def OnSetPhase_sP( self, e ): 
     2571        "plotterWindow: phase menu entry." 
    23512572        _sendShCommand( "@PHASE DEFAULT_PHASE sP" ) 
    23522573    def OnSetPhase_PP( self, e ): 
     2574        "plotterWindow: phase menu entry." 
    23532575        _sendShCommand( "@PHASE DEFAULT_PHASE PP" ) 
    23542576    def OnSetPhase_S( self, e ): 
     2577        "plotterWindow: phase menu entry." 
    23552578        _sendShCommand( "@PHASE DEFAULT_PHASE S" ) 
    23562579    def OnSetPhase_PKP( self, e ): 
     2580        "plotterWindow: phase menu entry." 
    23572581        _sendShCommand( "@PHASE DEFAULT_PHASE PKP" ) 
    23582582    def OnSetPhase_PKPdf( self, e ): 
     2583        "plotterWindow: phase menu entry." 
    23592584        _sendShCommand( "@PHASE DEFAULT_PHASE PKPdf" ) 
    23602585    def OnSetPhase_PKPbc( self, e ): 
     2586        "plotterWindow: phase menu entry." 
    23612587        _sendShCommand( "@PHASE DEFAULT_PHASE PKPbc" ) 
    23622588    def OnSetPhase_PKPab( self, e ): 
     2589        "plotterWindow: phase menu entry." 
    23632590        _sendShCommand( "@PHASE DEFAULT_PHASE PKPab" ) 
    23642591    def OnSetPhase_pPKPdf( self, e ): 
     2592        "plotterWindow: phase menu entry." 
    23652593        _sendShCommand( "@PHASE DEFAULT_PHASE pPKPdf" ) 
    23662594    def OnSetPhase_pPKPbc( self, e ): 
     2595        "plotterWindow: phase menu entry." 
    23672596        _sendShCommand( "@PHASE DEFAULT_PHASE pPKPbc" ) 
    23682597    def OnSetPhase_pPKPab( self, e ): 
     2598        "plotterWindow: phase menu entry." 
    23692599        _sendShCommand( "@PHASE DEFAULT_PHASE pPKPab" ) 
    23702600 
    23712601    def OnSetPhaseUseEvPhase( self, e ): 
     2602        "plotterWindow: phase menu entry." 
    23722603        _sendShCommand( "@PHASE DEFAULT_PHASE %s" 
    23732604            % AnalysisPar().getValueAsString('ev_phase')) 
     2605 
    23742606    def OnTheoPhaseLocal( self, e ): 
     2607        "plotterWindow: phase menu entry." 
    23752608        plist = AnalysisPar().getValue('phaselist') 
    23762609        if plist == None or plist == "": 
    23772610            plist = "Pg,Sg,Pn,Sn" 
    23782611        _sendShCommand( "phase clear ;;; theo\n@THEOPHASE local all %s" % plist ) 
     2612 
    23792613    def OnTheoPhaseTele( self, e ): 
     2614        "plotterWindow: phase menu entry." 
    23802615        _sendShCommand( "phase clear ;;; theo\ntheophase iasp91 all" ) 
     2616 
    23812617    def OnDeleteTheoPhase( self, e ): 
     2618        "plotterWindow: phase menu entry." 
    23822619        _sendShCommand( "phase clear ;;; theo /redraw" ) 
    2383     def redraw(self): 
    2384         self.canvas.OnSize(None) 
    2385      
    2386     def setZoomWindow( self, trace, start, end ): 
    2387         self._seltrace = trace 
    2388         self._zoomwdw = (start,end) 
     2620 
     2621    def OnMagnMlAnalytic( self, e ): 
     2622        "plotterWindow: magnitude menu entry." 
     2623        if self._seltrace: 
     2624            cmd = "@MAGNITUDE determine ml 1-%d Pg,Sg,Pn,Sn 8" % self._seltrace 
     2625        else: 
     2626            cmd = "@MAGNITUDE determine ml all Pg,Sg,Pn,Sn 8" 
     2627        _sendShCommand( cmd ) 
     2628     
     2629    def OnMagnMlAnalyticSingle( self, e ): 
     2630        "plotterWindow: magnitude menu entry." 
     2631        try: 
     2632            timea, timeb = self._zoomwdw 
     2633        except: 
     2634            timea = timeb = None 
     2635        if timea == None or not self._seltrace: 
     2636            self.showMessage( "No trace selected" ) 
     2637            return 
     2638        cmd = "magnitude determine ml %d %g %g" % (self._seltrace,timea,timeb) 
     2639        print "dbg: cmd", cmd 
     2640        _sendShCommand( cmd ) 
     2641     
     2642    def OnMagnMlDeleteAll( self, e ): 
     2643        "plotterWindow: magnitude menu entry." 
     2644        _sendShCommand( "magnitude clear ml" ) 
     2645 
     2646    def OnMagnMlDeleteSingle( self, e ): 
     2647        "plotterWindow: magnitude menu entry." 
     2648        if not self._seltrace: 
     2649            self.showMessage( "No trace selected" ) 
     2650            return 
     2651        cmd = "magnitude clear ml %d" % self._seltrace 
     2652        _sendShCommand( cmd ) 
     2653 
     2654    def OnMagnMlPlot( self, e ): 
     2655        "plotterWindow: magnitude menu entry." 
     2656        _sendShCommand( "magnitude plot ml" ) 
    23892657 
    23902658 
     
    23922660 
    23932661    def __init__( self, parent ): 
     2662        "ParamDialog: init method." 
    23942663        wx.Dialog.__init__( self, parent, -1, title="Parameters", 
    23952664            style=wx.SUNKEN_BORDER )         
     
    24312700     
    24322701    def OnButton( self, pname, e, *args ): 
     2702        "ParamDialog: button event." 
    24332703        oldvalue = self.ap.getValueAsString( pname ) 
    24342704        ptype = self.ap.getType( pname ) 
     
    24572727     
    24582728    def updateVariables( self, *args ): 
     2729        "ParamDialog: update all values (strings) in dialog box." 
    24592730        for pname in self.ap.sortedParams(): 
    24602731            pvalue = self.ap.getValueAsString( pname ) 
     
    24622733     
    24632734    def validate( self, result, ptype ): 
     2735        "ParamDialog: validate user input according to data type." 
    24642736        if ptype == 'int': 
    24652737            try: 
     
    24942766 
    24952767    def __init__( self, parent, title, prompt, oldvalue ): 
     2768        "QueryString init method." 
    24962769        wx.Dialog.__init__( self, parent, -1, title ) 
    24972770        self.SetBackgroundColour( shxcolor1 ) 
     
    25192792     
    25202793    def OnTextOk( self, e ): 
     2794        "QueryString: OK button." 
    25212795        self.result = self.text.GetValue() 
    25222796        self.Destroy() 
    25232797     
    25242798    def OnTextCancel( self, e ): 
     2799        "QueryString: cancel button." 
    25252800        self.result = None 
    25262801        self.Destroy() 
    25272802     
    25282803    def getValue( self ): 
     2804        "QueryString: access to result." 
    25292805        return self.result 
    25302806         
    25312807 
     2808def _absToRelTime( trc, abstime ): 
     2809    "Convert absolute (trace) time to relative (time axis) time." 
     2810    return (abstime - trc.stats.starttime + trc.get_info('t-origin')) 
     2811 
     2812def _relToAbsTime( trc, reltime ): 
     2813    "Convert relative (time axis) time into absolute (trace) time." 
     2814    return (trc.stats.starttime + reltime - trc.get_info('t-origin')) 
    25322815 
    25332816 
  • SHX/trunk/SeismicHandler/patches/obspy_.py

    r1136 r1148  
    412412    self.stats.sh.ORIGINAL = isoriginal 
    413413    self.stats.sh.DATASOURCE = 'UNKNOWN' 
     414    self.stats.sh.SIMUL = '' 
    414415 
    415416    # unknown 
Note: See TracChangeset for help on using the changeset viewer.