Changeset 1187 for SHX


Ignore:
Timestamp:
01.03.2016 08:03:42 (4 years ago)
Author:
klaus
Message:

first code for pick time uncertainties

Location:
SHX/trunk/SeismicHandler
Files:
3 edited

Legend:

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

    r1185 r1187  
    4141    PICKTYPE_MARK   : 'violet', 
    4242} 
     43typeshades = { 
     44    PICKTYPE_MANUAL : '#FFBBBB', 
     45    PICKTYPE_THEO   : 'lightgreen', 
     46    PICKTYPE_AUTO   : 'orange', 
     47    PICKTYPE_MARK   : 'violet', 
     48} 
    4349 
    4450 
     
    4955 
    5056    def __init__( self, name=None, picktime=None, picktype=None, 
    51         comp=None, weight=None ): 
     57        comp=None, weight=None, channel=None, left_error=0., right_error=0. ): 
    5258        # name of phase 
    5359        self.name = name 
     
    6066        # phase weight 
    6167        self.weight = weight 
     68        # pick time errors 
     69        self.left_error = left_error 
     70        self.right_error = right_error 
     71        # channel info (used as additional info, only one phase of a (name,type) 
     72        # pair allowed on a station). 
     73        self.channel = channel 
    6274 
    6375 
     
    7486    def __init__( self ): 
    7587        self.phasedict = {} 
    76         self.default_phase = 'P' 
     88        self.default_phasename = 'P' 
    7789        self.default_weight = 9 
    7890     
     
    97109            return 'gray' 
    98110     
     111    def picktypeShade( self, picktype ): 
     112        try: 
     113            return typeshades[picktype] 
     114        except: 
     115            return 'gray' 
     116     
    99117    def phaseAlreadyPicked( self, station, name=None, picktype=None ): 
    100118        "Returns True if phase of given type is already picked at station." 
     
    107125            picktype = DEFAULT_PICKTYPE 
    108126        if name == None: 
    109             name = self.default_phase 
     127            name = self.default_phasename 
    110128        for phase in self.phasedict[upstat]: 
    111129            if phase.name == name and phase.picktype == picktype: 
     
    120138            picktype = DEFAULT_PICKTYPE 
    121139        if name == None: 
    122             name = self.default_phase 
     140            name = self.default_phasename 
    123141        if weight == None: 
    124142            weight = self.default_weight 
     
    176194     
    177195    def getPhaseList( self, station, picktype=None, comp=None, minweight=None, 
    178         weight=None ): 
     196        weight=None, copy=True ): 
    179197        "Returns list of phases." 
    180198        if station not in self.phasedict.keys(): 
     
    190208            if weight and phase.weight != weight: 
    191209                continue 
    192             # append copy of phase 
    193             ret.append( Phase( 
    194                 name=phase.name, 
    195                 picktime=phase.picktime, 
    196                 picktype=phase.picktype, 
    197                 comp=phase.comp, 
    198                 weight=phase.weight, 
    199             ) ) 
     210            if copy: 
     211                # append copy of phase 
     212                ret.append( Phase( 
     213                    name=phase.name, 
     214                    picktime=phase.picktime, 
     215                    picktype=phase.picktype, 
     216                    comp=phase.comp, 
     217                    weight=phase.weight, 
     218                    channel=phase.channel, 
     219                    right_error=phase.right_error, 
     220                    left_error=phase.left_error 
     221                ) ) 
     222            else: 
     223                ret.append( phase ) 
    200224        return ret 
    201225     
     
    208232        return None 
    209233     
    210     def setDefaultPhase( self, phase ): 
    211         self.default_phase = phase 
     234    def setDefaultPhase( self, phasename ): 
     235        self.default_phasename = phasename 
    212236     
    213237    def getDefaultPhase( self ): 
    214         return self.default_phase 
     238        return self.default_phasename 
    215239 
    216240    def setDefaultWeight( self, weight ): 
     
    232256                    pdict[phase.name] = [(station,phase.picktime)] 
    233257        return pdict 
    234  
     258        
     259    def setPickLeftError( self, station, phasename, left_error ): 
     260        for phase in self.getPhaseList(station,PICKTYPE_MANUAL,copy=False): 
     261            if phase.name == phasename: 
     262                phase.left_error = left_error 
     263 
     264    def setPickRightError( self, station, phasename, right_error ): 
     265        for phase in self.getPhaseList(station,PICKTYPE_MANUAL,copy=False): 
     266            if phase.name == phasename: 
     267                phase.right_error = right_error 
    235268 
    236269#------------------------------------------------------------------------------- 
  • SHX/trunk/SeismicHandler/commands/phase.py

    r1185 r1187  
    4040    PHASE PLOT [<outfile>] 
    4141    PHASE SLOWNESS <phase> [<slovar>] [<azvar>] [<sloerrvar>] [<azerrvar>] 
     42    PHASE SET_LEFT_ERROR <station> <phasename> 
    4243 
    4344    [Wiki Doc Text] 
     
    6364    '''command''': PHASE PLOT[[br]] 
    6465    or[[br]] 
    65     '''command''': PHASE SLOWNESS <phasename> [<slovar>] [<azvar>] [<sloerrvar>] [<azerrvar>] 
     66    '''command''': PHASE SLOWNESS <phasename> [<slovar>] [<azvar>] [<sloerrvar>] [<azerrvar>][[br]] 
     67    or[[br]] 
     68    '''command''': PHASE SET_LEFT_ERROR <station> <phasename>[[br]] 
     69    or[[br]] 
     70    '''command''': PHASE SET_RIGHT_ERROR <station> <phasename>[[br]] 
    6671 
    6772    Command to modify or operate on internal phase list. This command is not meant 
     
    106111       PLOT: create phase plot and show it on screen[[br]] 
    107112       SLOWNESS: determine slowness and azimuth for specified phase including error estimates, results put in up to four variables[[br]] 
     113       SET_LEFT_ERROR: set left uncertainty of phase pick[[br]] 
     114       SET_RIGHT_ERROR: set right uncertainty of phase pick[[br]] 
    108115 
    109116 
     
    217224                    fromUTCDateTime(phase.picktime), 
    218225                    phaselist.picktypeName(phase.picktype),phase.comp) 
     226        elif subcmd == 'set_left_error': 
     227            station = addNetcode( self.parameters[1] ) 
     228            phasename = self.parameters[2] 
     229            error = float( self.parameters[3] ) 
     230            phaselist.setPickLeftError( station, phasename, error ) 
     231        elif subcmd == 'set_right_error': 
     232            station = addNetcode( self.parameters[1] ) 
     233            phasename = self.parameters[2] 
     234            error = float( self.parameters[3] ) 
     235            phaselist.setPickRightError( station, phasename, error ) 
    219236        elif subcmd == 'default_phase': 
    220237            phase = self.parameters[1] 
     
    254271            for sta in phaselist.getStations(): 
    255272                for phase in phaselist.getPhaseList(sta): 
    256                     print "%8s %5s %s %s %s" % (sta,phase.name, 
    257                         fromUTCDateTime(phase.picktime), 
     273                    print "%8s %5s %s -%4.2f+%4.2f %s %s" % (sta,phase.name, 
     274                        fromUTCDateTime(phase.picktime),phase.left_error, 
     275                        phase.right_error, 
    258276                        phaselist.picktypeName(phase.picktype),phase.comp) 
    259277        elif subcmd == 'plot': 
  • SHX/trunk/SeismicHandler/modules/wx_.py

    r1186 r1187  
    271271    def refresh( self ): 
    272272        "magnifyCanvas: redraw content of window." 
     273        self._drawPicks() 
    273274        self._drawMagnifyTrace() 
    274         self._drawPicks() 
    275275 
    276276    def _closePhase( self, abstime ): 
     
    289289        return None 
    290290     
    291     def _drawMagnifyTrace( self, clear=True, othertrace=None, yoffset=0., 
     291    def _drawMagnifyTrace( self, othertrace=None, yoffset=0., 
    292292        color=(0,0,0), norm=None ): 
    293293        "magnifyCanvas: does the drawing work." 
     
    308308        # negative scaling due to inversed pixel addressing in y direction 
    309309        amplscale = -1./norm * self.pixheight/2. 
    310         self._magn_bitmap = wx.EmptyBitmap(self.pixwidth, self.pixheight) 
     310        #self._magn_bitmap = wx.EmptyBitmap(self.pixwidth, self.pixheight) 
    311311        mdc = wx.MemoryDC(self._magn_bitmap) 
    312312        mdc.SetBrush(wx.TRANSPARENT_BRUSH) 
    313         if clear: 
    314             mdc.Clear() 
    315313        mdc.SetFont(wx.Font(8, wx.SWISS, wx.NORMAL, wx.NORMAL)) 
    316314        mdc.SetPen(wx.Pen(color, 1)) 
     
    336334        self.Update() 
    337335     
    338     def _drawPicks( self ): 
     336    def _drawPicks( self, clear=True ): 
    339337        "magnifyCanvas: add picks to waveform." 
    340338        if self.trc == None: 
     
    342340        phaselist = PhaseList() 
    343341        _picks = {} 
     342        _areas = {} 
    344343        sname = "%s.%s" % (self.trc.stats.network,self.trc.stats.station) 
    345344        for phase in phaselist.getPhaseList(sname): 
     
    352351                ( phase.name, self._toScreenCoo(phase.picktime) ) 
    353352            ) 
     353            if phase.left_error > 0. or phase.right_error > 0.: 
     354                scol = phaselist.picktypeShade( phase.picktype ) 
     355                if scol not in _areas.keys(): 
     356                    _areas[scol] = [] 
     357                _areas[scol].append( 
     358                    ( self._toScreenCoo(phase.picktime-phase.left_error), 
     359                    self._toScreenCoo(phase.picktime+phase.right_error) ) 
     360                ) 
     361        self._magn_bitmap = wx.EmptyBitmap(self.pixwidth, self.pixheight) 
    354362        dc = wx.MemoryDC(self._magn_bitmap)  # mdc 
     363        if clear: 
     364            dc.Clear() 
    355365        #dc = wx.ClientDC(self) 
    356366        dc.SetBrush(wx.TRANSPARENT_BRUSH) 
     
    359369        yup = self.pixheight - pickborder 
    360370        ydn = pickborder 
     371        # draw pick errors 
     372        for scolor in _areas.keys(): 
     373            dc.SetBrush( wx.Brush(scolor,wx.SOLID) ) 
     374            dc.SetPen(wx.Pen(scolor,1)) 
     375            for xlo,xhi in _areas[scolor]: 
     376                dc.DrawRectangle( xlo, ydn, xhi-xlo, yup-ydn ) 
    361377        # draw picks 
    362378        for pcolor in _picks.keys(): 
     
    434450        else: 
    435451            self.trc = trc 
    436         clearwdw = True 
     452        self._drawPicks( True ) 
    437453        if self._s3_showalltraces and len(self._s3_othertraces) > 0: 
    438454            try: 
     
    441457                return 
    442458            self._s3_showOtherTraces( norm ) 
    443             clearwdw = False 
    444         self._drawMagnifyTrace( clearwdw ) 
    445         self._drawPicks() 
     459        self._drawMagnifyTrace() 
    446460     
    447461    def clearWindow( self ): 
     
    496510        yoffset = -self.pixheight/5 
    497511        ystep = 2*self.pixheight/5 
    498         clearwdw = True 
    499512        for trc in self._s3_othertraces: 
    500513            otrc = trc.slice(self.trc.stats.starttime,self.trc.stats.endtime) 
     
    506519                print "dbg: s3: other trace stange start time" 
    507520                continue 
    508             self._drawMagnifyTrace( clearwdw, otrc, yoffset, 
     521            self._drawMagnifyTrace( otrc, yoffset, 
    509522                color=(200,200,200), norm=norm ) 
    510523            yoffset += ystep 
    511             clearwdw = False 
    512524     
    513525    def toggleShowAllTraces( self ): 
Note: See TracChangeset for help on using the changeset viewer.