Changeset 1145


Ignore:
Timestamp:
27.01.2016 23:52:42 (4 years ago)
Author:
klaus
Message:

trace scroll; spectrogram; wood-anderson incl. 1Hz)

Location:
SHX/trunk/SeismicHandler
Files:
1 added
7 edited

Legend:

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

    r1144 r1145  
    224224        'source_depth'    : ( 50, 'floatN',    None, 1), 
    225225        'depth_type'      : ( 51, 'string',    'unknown', 1), 
     226        'origin_time'     : ( 52, 'datetime',  None, 1), 
    226227        # trace read parameters 
    227228        'read_time'       : ( 60, 'datetime',  toUTCDateTime('7-AUG-2015_00:16:30'), 2), 
  • SHX/trunk/SeismicHandler/cmdscripts/SHX_MENU_FILTER.SHC

    r1139 r1145  
    11 
    22default 1 BP_1HZ_8HZ_4  filter 
     3default 2 ;;  cutoff at beginning 
    34 
    45if #1 eqs undo goto skipfili: 
     
    1516    filter f all 
    1617    hide _original(y) 
     18    if #2 eqs ;; goto cutok: 
     19        cut all #2 999999 
     20        set all t-origin 0. 
     21        shift all time_al 
     22    cutok: 
    1723 
    1824undo: 
  • SHX/trunk/SeismicHandler/cmdscripts/SHX_MENU_SIMULATE.SHC

    r1120 r1145  
    11 
    22default 1 wwssn-sp  instrument 
     3default 2 ;;        hp freq 
     4default 3 ;;        cutoff at beginning 
    35 
    46nr 
     
    810if #1 eqs undo goto undo: 
    911 
    10     simulate all #1 
     12    if #2 eqs ;; goto nohp: 
     13        simulate all #1 /lofrq=#2 
     14        goto hpok: 
     15    nohp: 
     16        simulate all #1 
     17    hpok: 
    1118    hide _original(y) 
     19     
     20    if #3 eqs ;; goto cutok: 
     21        cut all #3 999999 
     22        set all t-origin 0. 
     23        shift all time_al 
     24    cutok: 
    1225 
    1326undo: 
  • SHX/trunk/SeismicHandler/commands/locate.py

    r1143 r1145  
    1010from SeismicHandler.basics.analysispar import AnalysisPar 
    1111from SeismicHandler.basics.messages import ui_event 
     12from obspy.sh.core import fromUTCDateTime 
    1213 
    1314provides = {"locate": "locate"} 
     
    1920    parameterQueries = [ 
    2021        { 
    21             "text": "locator name", 
     22            "text": "locator string", 
    2223            "type": "str", 
    2324            "question": False, 
     
    8990         
    9091        loc = locator( **pars ) 
    91         lat, lon, depth, depth_type = loc.locate() 
     92        orig, lat, lon, depth, depth_type = loc.locate() 
    9293         
    9394        if lat != None: 
     
    99100        if depth_type != None: 
    100101            ap.setValueFromString( 'depth_type', depth_type ) 
     102        if orig != None: 
     103            ap.setValueFromString( 'origin_time', fromUTCDateTime(orig) ) 
    101104        ui_event( "updateparams" ) 
    102105         
  • SHX/trunk/SeismicHandler/commands/plot_stations.py

    r1118 r1145  
    1313from SeismicHandler.basics import timeit 
    1414from SeismicHandler.basics.error import ShxError 
     15from SeismicHandler.basics.analysispar import PhaseList 
    1516from obspy.imaging.maps import plot_basemap 
    1617import matplotlib.pyplot as plt 
     
    4243        "SHOW", 
    4344        "ADDLOC", 
     45        "TITLE", 
    4446    ] 
    4547     
     
    5355 
    5456        self.stations = Stations() 
    55         traces = traces_from_list(self.parameters[0]) 
     57        trcstring = self.parameters[0].lower() 
     58        if trcstring == 'withphases': 
     59            traces = traces_from_list('all') 
     60            withphases = True 
     61        else: 
     62            traces = traces_from_list(trcstring) 
     63            withphases = False 
    5664        projection = "local" 
    5765        if len(self.parameters) > 1: 
     
    6472            show = True 
    6573        if projection == "local": 
    66             resolution = 'i' 
     74            resolution = 'h' 
    6775        else: 
    6876            resolution = 'l' 
     
    7684            except: 
    7785                print "Cannot parse ADDLOC values" 
     86        title = None 
     87        if self.qualifiers["TITLE"]: 
     88            title = self.qualifiers["TITLE"].replace('_',' ') 
    7889 
     90        if withphases: 
     91            stalist = PhaseList().getStations() 
     92        else: 
     93            stalist = None 
    7994        p_lons = [] 
    8095        p_lats = [] 
     
    85100            label = "%s.%s" % (trc.stats.network,trc.stats.station) 
    86101            if label in p_labels: 
     102                continue 
     103            if stalist != None and label not in stalist: 
    87104                continue 
    88105            sname = "%s.%s.%s.%s" % (trc.stats.network, trc.stats.station, 
     
    118135        fig = plot_basemap( p_lons, p_lats, p_sizes, p_colors, p_labels, 
    119136            projection=projection, resolution=resolution, show=False, 
    120             colorbar=False ) 
     137            colorbar=False, title=title ) 
    121138        plt.savefig( outfile ) 
    122139        plt.close( "all" ) 
  • SHX/trunk/SeismicHandler/modules/locator.py

    r1143 r1145  
    5858        self.alroot = os.path.join( self.scratch, 'locsat' ) 
    5959        self.prefix = 'locsat' 
     60        self.reftime = None 
    6061        if not 'modelname' in kwargs: 
    6162            print "need modelname in parameters" 
     
    119120        clat = self.phaselist[0][1] 
    120121        clon = self.phaselist[0][2] 
    121         reftime = self.phaselist[0][4] 
     122        self.reftime = self.phaselist[0][4] 
    122123        for station,slat,slon,elev,ptime,pname in self.phaselist: 
    123             if ptime < reftime: 
    124                 reftime = ptime 
     124            if ptime < self.reftime: 
     125                self.reftime = ptime 
    125126                clat = slat 
    126127                clon = slon 
    127128        fp = open( fname, 'w' ) 
    128         fp.write( "%02d%02d%02d %02d%02d%3d.%02d" % ((reftime.year % 100), 
    129             reftime.month,reftime.day,reftime.hour,reftime.minute, 
    130             reftime.second,reftime.microsecond/10) ) 
     129        fp.write( "%02d%02d%02d %02d%02d%3d.%02d" % ((self.reftime.year % 100), 
     130            self.reftime.month,self.reftime.day,self.reftime.hour, 
     131            self.reftime.minute,self.reftime.second, 
     132            self.reftime.microsecond/10) ) 
    131133        if self.fixeddepth == None: 
    132134            depth = 0. 
     
    137139        for station,slat,slon,elev,ptime,pname in self.phaselist: 
    138140            sta = station.split('.')[1] 
    139             tdiff = ptime - reftime 
     141            tdiff = ptime - self.reftime 
    140142            fp.write( "%8d %6s %8s %4s%2s %f %f\n" % (cnt,sta,pname, 
    141143                "t","d",tdiff,1.0) ) 
     
    166168        if not os.path.exists(fname): 
    167169            return (None,None,None,None) 
    168         lat = lon = depth = None 
     170        lat = lon = depth = relot = None 
    169171        for line in file(fname): 
    170172            if line.strip().startswith('Latitude:'): 
     
    174176            if line.strip().startswith('Depth:'): 
    175177                depth = float( line.split()[1] ) 
     178            if line.strip().startswith('Relative O.T.:'): 
     179                relot = float( line.split()[2] ) 
    176180        if self.fixeddepth == None: 
    177181            depth_type = 'located' 
    178182        else: 
    179183            depth_type = 'fixed' 
    180         return (lat,lon,depth,depth_type) 
     184        if relot != None: 
     185            orig = self.reftime + relot 
     186        else: 
     187            orig = None 
     188        return (orig,lat,lon,depth,depth_type) 
    181189         
  • SHX/trunk/SeismicHandler/modules/wx_.py

    r1144 r1145  
    4242# holds window instance 
    4343plotter = None 
     44 
     45displayselect = None 
    4446 
    4547class magnifyCanvas(wx.Panel): 
     
    144146 
    145147        # Send SH command to define/clear phase if not waiting for user input. 
     148        # Redraw of main window only if less than 50 traces. 
     149        if displayselect or len(Traces) < 50: 
     150            qredraw = '/REDRAW' 
     151        else: 
     152            qredraw = '' 
    146153        if self._mousedouble: 
    147154            if self._last_defined_phase: 
    148                 _sendShCommand( "@PHASE CLEAR %s %s manual /SMARTREDRAW" % ( 
    149                     self._last_defined_phase,station.upper()) ) 
     155                _sendShCommand( "@PHASE CLEAR %s %s manual %s" % ( 
     156                    self._last_defined_phase,station.upper(),qredraw) ) 
    150157        else: 
    151             _sendShCommand( "@PHASE DEFINE %s %s ;;; %s /SMARTREDRAW" % (station.upper(), 
    152                 fromUTCDateTime(abstime),self.trc.stats.channel[-1].upper()), 
    153                 name="mouse evt" ) 
    154             #self._drawSinglePick( trace, tracetime ) 
     158            _sendShCommand( "@PHASE DEFINE %s %s ;;; %s %s" % (station.upper(), 
     159                fromUTCDateTime(abstime),self.trc.stats.channel[-1].upper(), 
     160                qredraw), name="mouse evt" ) 
    155161        self.refresh() 
    156162        self._mousedouble = False 
     
    195201            self.clearWindow() 
    196202            return 
    197         norm = max( abs(max(self.trc.data)), abs(min(self.trc.data)) ) 
     203        try: 
     204            norm = max( abs(max(self.trc.data)), abs(min(self.trc.data)) ) 
     205        except: 
     206            self.clearWindow() 
     207            return 
    198208        amplscale = 1./norm * self.pixheight/2. 
    199209        self._magn_bitmap = wx.EmptyBitmap(self.pixwidth, self.pixheight) 
     
    314324        if not self.trc or not self.pixwidth: 
    315325            return 0. 
    316         return ((abstime-self.trc.stats.starttime) \ 
    317             /(self.trc.stats.endtime-self.trc.stats.starttime) * self.pixwidth) 
     326        tdiff = self.trc.stats.endtime-self.trc.stats.starttime 
     327        if tdiff == 0.: 
     328            return 0. 
     329        return ((abstime-self.trc.stats.starttime) / tdiff * self.pixwidth) 
    318330     
    319331    def _fromScreenCoo( self, xpix, mode='abs' ): 
     
    390402        self.Bind(wx.EVT_RIGHT_DOWN, self.OnMouseRightDown) 
    391403        self.Bind(wx.EVT_LEFT_DOWN, self.OnMouseLeftDown) 
    392         self.Bind(wx.EVT_SCROLLWIN, self.OnScroll) 
     404        #self.Bind(wx.EVT_SCROLLWIN, self.OnScroll) 
    393405        self.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel) 
    394406        self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyDown) 
     
    494506        wheel = evt.GetWheelRotation() 
    495507        if wheel > 0: 
    496             if self.wheelpos < maxwheelpos: 
    497                 _sendShCommand( "zoom/rel all 2" ) 
    498                 self.wheelpos += 1 
     508            #if self.wheelpos < maxwheelpos: 
     509            #    _sendShCommand( "zoom/rel all 2" ) 
     510            #    self.wheelpos += 1 
     511            _scrollTraces( 'up' ) 
    499512        elif wheel < 0: 
    500             if self.wheelpos > -maxwheelpos: 
    501                 _sendShCommand( "zoom/rel all 0.5" )             
    502                 self.wheelpos -= 1 
     513            #if self.wheelpos > -maxwheelpos: 
     514            #    _sendShCommand( "zoom/rel all 0.5" )             
     515            #    self.wheelpos -= 1 
     516            _scrollTraces( 'down' ) 
    503517        evt.Skip() 
    504518 
     
    556570            start = self.TraceAndTimeToScreen(trace, start) 
    557571            end = self.TraceAndTimeToScreen(trace, end) 
     572            if start[0] == None or end[0] == None: 
     573                self.ZoomWindow = None 
     574                return 
    558575            self.zoomwdwwidth = end[0] - start[0] 
    559576        else: 
     
    702719 
    703720        # Send SH command to define/clear phase if not waiting for user input. 
     721        # Redraw of main window only if less than 50 traces on display. 
     722        if displayselect or len(Traces) < 50: 
     723            qredraw = "/REDRAW" 
     724        else: 
     725            qredraw = "" 
    704726        if self.mousedouble: 
    705727            if self.last_defined_phase: 
    706728                station = "%s.%s" % (trace.stats.network,trace.stats.station) 
    707                 _sendShCommand( "@PHASE CLEAR %s %s manual /SMARTREDRAW" % ( 
    708                     self.last_defined_phase,station.upper()) ) 
     729                _sendShCommand( "@PHASE CLEAR %s %s manual %s" % ( 
     730                    self.last_defined_phase,station.upper(),qredraw) ) 
    709731        elif trace and self.parent._user_selection: 
    710732            station = "%s.%s" % (trace.stats.network,trace.stats.station) 
    711             _sendShCommand( "@PHASE DEFINE %s %s ;;; %s /SMARTREDRAW" % (station.upper(), 
    712                 fromUTCDateTime(tracetime),trace.stats.channel[-1].upper()), 
    713                 name="mouse evt" ) 
     733            _sendShCommand( "@PHASE DEFINE %s %s ;;; %s %s" % (station.upper(), 
     734                fromUTCDateTime(tracetime),trace.stats.channel[-1].upper(), 
     735                qredraw), name="mouse evt" ) 
    714736            self._drawSinglePick( trace, tracetime ) 
    715737            if plotter.magnify: 
     
    730752        Update scroll offset. 
    731753        """ 
     754        print "dbg: on scroll" 
    732755        if self.traceOrder in [0, 1]: 
    733756            self.Scrolled = self.GetScrollPos(wx.VERTICAL) * \ 
     
    896919                continue 
    897920            if 'midpoint' not in shx_graphics: 
     921                continue 
     922            if shx_graphics.midpoint == None: 
    898923                continue 
    899924            if tracepos >= shx_graphics.midpoint - theight and \ 
     
    964989        """ 
    965990        if trace is None: 
    966             return 
     991            return (None,None) 
    967992        shx_graphics = trace.get_graphics() 
    968993        if shx_graphics == None: 
    969             return 
     994            return (None,None) 
     995        if shx_graphics.midpoint == None: 
     996            return (None,None) 
    970997 
    971998        # horizontal 
     
    10591086                if pcol not in _picks.keys(): 
    10601087                    _picks[pcol] = [] 
    1061                 _picks[pcol].append( 
    1062                     (phase.name,self.TraceAndTimeToScreen(trc,phase.picktime)) 
    1063                 ) 
     1088                ppos = self.TraceAndTimeToScreen(trc,phase.picktime) 
     1089                if ppos[0] != None: 
     1090                    _picks[pcol].append( (phase.name,ppos) ) 
    10641091 
    10651092        if not _picks and not self.ZoomWindow: 
     
    11481175        self.width, self.height = self.GetVirtualSize() 
    11491176        numTraces = len(self.traces) - Overlays.numberOfOverlays() 
     1177        if displayselect: 
     1178            dsptmp = displayselect[1]-displayselect[0]+1 
     1179            if dsptmp < numTraces: 
     1180                numTraces = dsptmp 
    11501181        globalnorm = self._normtype.startswith("A") 
    11511182 
     
    12141245 
    12151246        # Loop over traces. 
    1216         for i, t in enumerate(trcs): 
     1247        plotidx = 0 
     1248        for trccnt,t in enumerate(trcs): 
    12171249            if getattr(t, "shx_graphics", None) is None: 
    12181250                # Trace not yet established. 
    12191251                continue 
     1252            if displayselect: 
     1253                trcidx = t.index(True) 
     1254                if trcidx < displayselect[0] or trcidx > displayselect[1]: 
     1255                    shx_graphics = t.get_graphics() 
     1256                    if shx_graphics != None: 
     1257                        shx_graphics.midpoint = None 
     1258                    continue 
    12201259            if not self.relativeAxis: 
    12211260                start = self.start 
     
    13321371                if self.traceOrder in [0, 1]: 
    13331372                    if overlapping_traces: 
    1334                         fac = i + 0.5 - 0.5*tzoom 
     1373                        fac = plotidx + 0.5 - 0.5*tzoom 
    13351374                    else: 
    1336                         fac = i 
    1337                     plotpos = Overlays.plotPos( i+1, fac * theight + MARGINS[0]) 
     1375                        fac = plotidx 
     1376                    plotpos = Overlays.plotPos( plotidx+1, fac * theight + MARGINS[0]) 
    13381377                    canvas.Blit( 
    13391378                        plotoffset + STATION_INFO + MARGINS[3],  
     
    13471386                    ) 
    13481387                elif self.traceOrder == 2: 
    1349                     canvas.Blit(i * theight, -plotoffset + MARGIN, zheight, 
     1388                    canvas.Blit(plotidx * theight, -plotoffset + MARGIN, zheight, 
    13501389                                                pltwidth, dbuffer, 0, 0, wx.AND) 
    13511390                elif self.traceOrder == 3: 
    1352                     canvas.Blit(i * theight, STATION_INFO + plotoffset, zheight, 
     1391                    canvas.Blit(plotidx * theight, STATION_INFO + plotoffset, zheight, 
    13531392                                                pltwidth, dbuffer, 0, 0, wx.AND) 
    13541393 
     
    13561395            # Trace numbering 
    13571396            if self.traceOrder in [1, 2, 3]: 
    1358                 idx = i + 1 
     1397                idx = trccnt + 1 
    13591398            elif self.traceOrder == 0: 
    1360                 idx = -i + len(self.traces) 
     1399                idx = -trccnt + len(self.traces) 
    13611400            # Currently no choice on type of label, just station and component. 
    13621401            txt = "%d: %s %s" % (idx, t.stats.station, t.stats.channel[-1]) 
     
    13641403            # Draw labels and helper lines (zero lines) 
    13651404            w, h, _, _ = canvas.GetFullTextExtent(txt) 
    1366             shx_graphics.midpoint = tmp = i * theight + theight//2 + MARGINS[0] 
     1405            shx_graphics.midpoint = tmp = plotidx * theight + theight//2 + MARGINS[0] 
    13671406            if self.traceOrder in [0, 1]: 
    13681407                canvas.DrawText(txt, 5 + MARGINS[3], tmp - h // 2) 
     
    13781417                canvas.DrawLine(tmp, STATION_INFO, tmp, self.height - MARGIN) 
    13791418 
     1419            plotidx += 1 
    13801420            # End of trace loop 
    13811421 
     
    16191659            self._drawXor( 'rect', (None,None,None,None) ) 
    16201660            return 
     1661        if midpoint == None: 
     1662            return 
    16211663        marginfactor = 0.3 
    16221664        mf2 = (1 - marginfactor) * 2 
     
    16531695                return 
    16541696        elif direction == 'down': 
    1655             newtrc = traces_from_list( "%d" % (trace.index(True)-1) ) 
     1697            newidx = trace.index(True)-1 
     1698            if newidx == 0: 
     1699                return 
     1700            newtrc = traces_from_list( "%d" % newidx ) 
    16561701            if newtrc and len(newtrc) == 1: 
    16571702                trace = newtrc[0] 
     
    16931738    Shortcuts 
    16941739           b(Beam) d(DelTimeWdw) g(PhasePg) l(locate) n(PhasePn) p(PhaseP) 
    1695            s(SetTimeWdw) u(Undo Filter) 0(PrevEvent) 1(NextEvent) 2(PhaseSg) 
    1696            8(Filter 1-8Hz) >(zoom->right) <(zoom->left) 
     1740           s(SetTimeWdw) u(Undo Filter) w(FilterWA) 0(PrevEvent) 1(NextEvent) 
     1741           2(PhaseSg) 8(Filter 1-8Hz) >(zoom->right) <(zoom->left) 
    16971742    Ctrl-  f(FK) l(FilterSROLP) n(Norm) o(Overlapping) q(Quit) s(SaveT&P) 
    16981743           w(FilterWWSSNSP) y(SortByDistance) 
     
    17071752 
    17081753        #self.SetPosition(position) # positioning doesn't work 
     1754        self._menuitems = {} 
    17091755        self.addMenuEntries() 
    17101756        self.canvas = traceCanvas(self, []) 
     
    17631809            'Set Zoom window as new time window', self.OnSetTimeWindow ) 
    17641810        self.addEntry( windowMenu, '&Del Time Window\tD', 
    1765             'Delete time window', self.OnDelTimeWindow ) 
     1811            'Delete time window.', self.OnDelTimeWindow ) 
     1812        windowMenu.AppendSeparator() 
    17661813        self.addEntry( windowMenu, '&Move Zoom Right\t>', 
    1767             'move zoom window to the right', self.OnMoveZoomRight ) 
     1814            'Move zoom window to the right (50%).', self.OnMoveZoomRight ) 
    17681815        self.addEntry( windowMenu, 'Move Zoom Left\t<', 
    1769             'move zoom window to the left', self.OnMoveZoomLeft ) 
     1816            'Move zoom window to the left (50%).', self.OnMoveZoomLeft ) 
    17701817        self.addEntry( windowMenu, 'Move Zoom Up', 
    1771             'move zoom window upward', self.OnMoveZoomUp, accel=wx.WXK_UP ) 
     1818            'Move zoom window upward.', self.OnMoveZoomUp, accel=wx.WXK_UP ) 
    17721819        self.addEntry( windowMenu, 'Move Zoom Down', 
    1773             'move zoom window downward', self.OnMoveZoomDown ) 
     1820            'Move zoom window downward.', self.OnMoveZoomDown ) 
     1821        self.addEntry( windowMenu, 'Zoom Amplitudes Up\t+', 
     1822            'Zoom amplitudes up (factor 2).', self.OnAmplZoomUp ) 
     1823        self.addEntry( windowMenu, 'Zoom Amplitudes Down\t-', 
     1824            'Zoom amplitudes down (factor 0.5).', self.OnAmplZoomDown ) 
     1825        windowMenu.AppendSeparator() 
     1826        m = self.addEntry( windowMenu, 'Trace Scroll On', 
     1827            'Display at max 21 traces and enable scrolling.', 
     1828            self.OnTraceScrollOn ) 
     1829        self._menuitems['TraceScrollOn'] = m 
     1830        m = self.addEntry( windowMenu, 'Trace Scroll Off', 
     1831            'Display all traces, switches off scrolling.', 
     1832            self.OnTraceScrollOff ) 
     1833        self._menuitems['TraceScrollOff'] = m 
     1834        m = self.addEntry( windowMenu, 'Trace Scroll Up', 
     1835            'Scroll traces up. Use mouse wheel.', self.OnTraceScrollUp ) 
     1836        self._menuitems['TraceScrollUp'] = m 
     1837        m = self.addEntry( windowMenu, 'Trace Scroll Down', 
     1838            'Scroll traces down. Use mouse wheel', self.OnTraceScrollDown ) 
     1839        self._menuitems['TraceScrollDown'] = m 
     1840        windowMenu.AppendSeparator() 
    17741841        self.addEntry( windowMenu, '&Norm All/Single\tCtrl+N', 
    17751842            'Normalize All Traces Together / Normalize Traces Separately', 
     
    17921859            'Delete trace with zoom window and all above', 
    17931860            self.OnDeleteTraceAndAbove ) 
     1861        tracesMenu.AppendSeparator() 
     1862        self.addEntry( tracesMenu, 'Spectrogram', 
     1863            'Compute spectrogram', self.OnSpectrogram ) 
    17941864        # array menu 
    17951865        arrayMenu = wx.Menu() 
     
    18021872        # simulate menu 
    18031873        simulateMenu = wx.Menu() 
    1804         self.addEntry( simulateMenu, 'Simulate &WWSSN-SP\tCtrl+W', 
     1874        self.addEntry( simulateMenu, 'Simulate &Wood-Anderson\tW', 
     1875            'Simulate Wood-Anderson instrument on all traces', 
     1876            self.OnSimulateWoodAnderson ) 
     1877        self.addEntry( simulateMenu, 'Simulate Wood-Anderson-1Hz', 
     1878            'Simulate Wood-Anderson instrument + 1Hz-HP on all traces', 
     1879            self.OnSimulateWoodAnderson1Hz ) 
     1880        self.addEntry( simulateMenu, 'Simulate WWSSN-SP\tCtrl+W', 
    18051881            'Simulate WWSSN-SP instrument on all traces', self.OnSimulateWWSSNSP ) 
    18061882        self.addEntry( simulateMenu, 'Simulate WWSSN-LP', 
     
    18311907        self.addEntry( eventsMenu, 'Locate Event\tl', 
    18321908            'Use phase list for locating event', self.OnLocateEvent ) 
     1909        self.addEntry( eventsMenu, 'Plot Location', 
     1910            'Simple map with stations and epicenter', self.OnPlotLocation ) 
    18331911        phaseMenu = wx.Menu() 
    18341912        self.addEntry( phaseMenu, 'Pg\tg', 
     
    19021980        menubar.Append( controlMenu, 'Control' ) 
    19031981        menubar.Append( testMenu, 'Test' ) 
     1982        self._menuitems['TraceScrollOff'].Enable(False) 
     1983        self._menuitems['TraceScrollUp'].Enable(False) 
     1984        self._menuitems['TraceScrollDown'].Enable(False) 
    19041985        self.SetMenuBar( menubar ) 
    19051986        self.Centre() 
     
    19171998        if accel: 
    19181999            item.SetAccel( wx.AcceleratorEntry(keyCode=accel) ) 
     2000        return item 
    19192001 
    19202002    def OnQuit( self, e ): 
     
    19642046        else: 
    19652047            _sendShCommand( "del |%d|-|$dsptrcs|" % self._seltrace ) 
     2048     
     2049    def OnSpectrogram( self, e ): 
     2050        if self._seltrace == None: 
     2051            self.showMessage( "no trace selected" ) 
     2052            return 
     2053        try: 
     2054            timea, timeb = self._zoomwdw 
     2055        except: 
     2056            timea = timeb = None 
     2057        if timea and timeb: 
     2058            cmd = "spectrogram %d %g %g" % (self._seltrace,timea,timeb) 
     2059        else: 
     2060            cmd = "spectrogram %d" % self._seltrace 
     2061        _sendShCommand( cmd ) 
     2062         
    19662063 
    19672064    def OnTest1( self, e ): 
     
    19882085    def OnMoveZoomDown( self, e ): 
    19892086        plotter.canvas.moveZoomWindow( 'down' ) 
     2087 
     2088    def OnAmplZoomUp( self, e ): 
     2089        _sendShCommand( "zoom/rel all 2" ) 
     2090 
     2091    def OnAmplZoomDown( self, e ): 
     2092        _sendShCommand( "zoom/rel all 0.5" ) 
     2093 
     2094    def OnTraceScrollOn( self, e ): 
     2095        global displayselect 
     2096        displayselect = (1,21) 
     2097        plotter.canvas.refresh = True 
     2098        self._menuitems['TraceScrollOn'].Enable(False) 
     2099        self._menuitems['TraceScrollOff'].Enable() 
     2100        self._menuitems['TraceScrollUp'].Enable() 
     2101        self._menuitems['TraceScrollDown'].Enable() 
     2102 
     2103    def OnTraceScrollOff( self, e ): 
     2104        global displayselect 
     2105        displayselect = None 
     2106        plotter.canvas.refresh = True 
     2107        self._menuitems['TraceScrollOn'].Enable() 
     2108        self._menuitems['TraceScrollOff'].Enable(False) 
     2109        self._menuitems['TraceScrollUp'].Enable(False) 
     2110        self._menuitems['TraceScrollDown'].Enable(False) 
     2111         
     2112    def OnTraceScrollUp( self, e ): 
     2113        _scrollTraces( 'up' ) 
     2114 
     2115    def OnTraceScrollDown( self, e ): 
     2116        _scrollTraces( 'down' ) 
    19902117 
    19912118    def OnReadDataFile( self, e ): 
     
    21002227        self.flag_beam = not self.flag_beam 
    21012228     
     2229    def OnSimulateWoodAnderson( self, e ): 
     2230        _sendShCommand( 'shx_menu_simulate wood-anderson ;; 5.' ) 
     2231 
     2232    def OnSimulateWoodAnderson1Hz( self, e ): 
     2233        _sendShCommand( 'shx_menu_simulate wood-anderson 1.0 5.' ) 
     2234 
    21022235    def OnSimulateWWSSNSP( self, e ): 
    2103         _sendShCommand( 'shx_menu_simulate wwssn-sp' ) 
     2236        _sendShCommand( 'shx_menu_simulate wwssn-sp ;; 5.' ) 
    21042237 
    21052238    def OnSimulateWWSSNLP( self, e ): 
    2106         _sendShCommand( 'shx_menu_simulate wwssn-lp' ) 
     2239        _sendShCommand( 'shx_menu_simulate wwssn-lp ;; 20.' ) 
    21072240 
    21082241    def OnSimulateLRSMSP( self, e ): 
    2109         _sendShCommand( 'shx_menu_simulate lrsm-sp' ) 
     2242        _sendShCommand( 'shx_menu_simulate lrsm-sp ;; 5.' ) 
    21102243 
    21112244    def OnSimulateLRSMLP( self, e ): 
    2112         _sendShCommand( 'shx_menu_simulate lrsm-lp' ) 
     2245        _sendShCommand( 'shx_menu_simulate lrsm-lp ;; 20.' ) 
    21132246 
    21142247    def OnSimulateKIRNOS( self, e ): 
    2115         _sendShCommand( 'shx_menu_simulate kirnos' ) 
     2248        _sendShCommand( 'shx_menu_simulate kirnos ;; 20' ) 
    21162249 
    21172250    def OnSimulateSROLP( self, e ): 
    2118         _sendShCommand( 'shx_menu_simulate sro-lp' ) 
     2251        _sendShCommand( 'shx_menu_simulate sro-lp ;; 30.' ) 
    21192252 
    21202253    def OnFilterBP_1_8( self, e ): 
    2121         _sendShCommand( 'shx_menu_filter bp_1hz_8hz_4' ) 
     2254        _sendShCommand( 'shx_menu_filter bp_1hz_8hz_4 5.' ) 
    21222255 
    21232256    def OnSimulateUndo( self, e ): 
     
    21432276    def OnLocateEvent( self, e ): 
    21442277        _sendShCommand( 'locate shxvar /showresult' ) 
     2278         
     2279    def OnPlotLocation( self, e ): 
     2280        ap = AnalysisPar() 
     2281        lat = ap.getValue( 'epi_latitude' ) 
     2282        lon = ap.getValue( 'epi_longitude' ) 
     2283        dep = ap.getValue( 'source_depth' ) 
     2284        orig = ap.getValueAsString( 'origin_time' ) 
     2285        title = "loc:_%s_%g,%g_dep:_%g_(%s)" % (orig,lat,lon,dep, 
     2286            ap.getValue('depth_type')) 
     2287        _sendShCommand( '@PLOT_STATIONS WITHPHASES LOCAL /ADDLOC=%g,%g /TITLE=%s' \ 
     2288            % (lat,lon,title) ) 
    21452289         
    21462290    def OnSaveTracesAndParamsQuick( self, e ): 
     
    22312375 
    22322376    def __init__( self, parent ): 
    2233         wx.Dialog.__init__( self, parent, -1, "Parameters" )         
     2377        wx.Dialog.__init__( self, parent, -1, title="Parameters", 
     2378            style=wx.SUNKEN_BORDER )         
     2379        self.SetBackgroundColour( shxcolor1 ) 
    22342380        height = 26 
    22352381        btnwidth = 70 
    22362382        vbox = wx.BoxSizer(wx.VERTICAL) 
    2237         self.SetBackgroundColour( 'white' ) 
     2383        vbox.Add( (5,5), 0, wx.ALL, 1 ) 
    22382384        self.vtext = {} 
    22392385        self.vbutton = {} 
    22402386 
    22412387        self.ap = AnalysisPar() 
     2388        lastgroup = self.ap.getGroup(self.ap.sortedParams()[0]) 
    22422389        for pname in self.ap.sortedParams(): 
    22432390            pvalue = self.ap.getValueAsString( pname ) 
    2244             if self.ap.getGroup(pname) % 2 == 0: 
    2245                 col = shxcolor1 
    2246             else: 
    2247                 col = shxcolor2 
     2391            if self.ap.getGroup(pname) != lastgroup: 
     2392                # add spacer 
     2393                sline = wx.StaticLine(self, name='group', size=(300,1)) 
     2394                #sline.SetForegroundColour( shxcolor2 ) 
     2395                vbox.Add( sline, 0, wx.ALL, 5 ) 
     2396                lastgroup = self.ap.getGroup(pname) 
    22482397            ptext = "%s : %s" % (pname,pvalue) 
    22492398            hbox = wx.BoxSizer(wx.HORIZONTAL) 
    22502399            self.vbutton[pname] = wx.Button( self, label='Change', 
    22512400                size=(btnwidth,height) ) 
    2252             self.vbutton[pname].SetBackgroundColour( col ) 
     2401            self.vbutton[pname].SetBackgroundColour( 'white' ) 
    22532402            self.vtext[pname] = wx.StaticText( self, label=ptext ) 
     2403            hbox.Add( (3,3), 0, wx.ALL, 1 ) 
    22542404            hbox.Add( self.vbutton[pname], 0, wx.RIGHT, 1 ) 
    22552405            hbox.Add( self.vtext[pname], 1, wx.ALIGN_CENTER_VERTICAL, 1 ) 
     
    22572407                self.vbutton[pname] ) 
    22582408            vbox.Add( hbox, 0, wx.LEFT, 1 ) 
     2409        vbox.Add( (5,5), 0, wx.ALL, 1 ) 
    22592410        vbox.SetSizeHints(self) 
    22602411        self.SetAutoLayout(True) 
     
    24032554    return _c 
    24042555 
     2556def _scrollTraces( direction ): 
     2557    global displayselect 
     2558    increment = 6 
     2559    if displayselect == None: 
     2560        return 
     2561    t1, t2 = displayselect 
     2562    trcno = len(Traces) 
     2563    if direction == 'up': 
     2564        t1 += increment 
     2565        t2 += increment 
     2566        while t2 > trcno: 
     2567            t2 -= 1 
     2568            t1 -= 1 
     2569    else: 
     2570        t1 -= increment 
     2571        t2 -= increment 
     2572        while t1 < 1: 
     2573            t1 += 1 
     2574            t2 += 1 
     2575    displayselect = (t1,t2) 
     2576    plotter.canvas.refresh = True 
    24052577 
    24062578@ui_events 
Note: See TracChangeset for help on using the changeset viewer.