コード例 #1
0
ファイル: test_plot.py プロジェクト: kwschultz/VQScripts
def fit_to_weibull(sim_file,beta_0,tau_0,event_range=None,magnitude_filter=None,section_filter=None):
    from scipy import optimize
    from pyvc import VCEvents,VCSimData
    
    fitfunc = lambda p,x: weibull_one(x,p[0],p[1])
    errfunc = lambda p,x,y: fitfunc(p,x) - y
    
    p0 = [beta_0,tau_0]
    
    
    with VCSimData() as sim_data:
        # open the simulation data file
        sim_data.open_file(sim_file)

        # instantiate the vc classes passing in an instance of the VCSimData
        # class
        events = VCEvents(sim_data)
        
        event_data = events.get_event_data(['event_number', 'event_year', 'event_magnitude', 'event_range_duration'], event_range=event_range, magnitude_filter=magnitude_filter, section_filter=section_filter)
    
    
    intervals = np.array([   x - event_data['event_year'][n-1]
                    for n,x in enumerate(event_data['event_year'])
                    if n != 0
                ])
    
    cumulative = {}
    
    cumulative['x'] = np.sort(intervals)
    cumulative['y'] = np.arange(float(intervals.size))/float(intervals.size)
    
    
    p1,success = optimize.leastsq(errfunc,p0[:],args=(cumulative['x'],cumulative['y']))

    print "\nBETA: {}".format(p1[0])
    print "TAU : {}\n".format(p1[1])
コード例 #2
0
ファイル: test_plot.py プロジェクト: kwschultz/VQScripts
def plot_number_area_data(sim_file, output_file=None, event_range=None):
    from pyvc import *
    from pyvc import vcplotutils
    
    #Can't handle plot label if no event_range given
    
    with VCSimData() as sim_data:
        # open the simulation data file
        sim_data.open_file(sim_file)
        
        # instantiate the vc events class passing in an instance of the
        # VCSimData class
        events = VCEvents(sim_data)
        
        # get the data
        event_data = events.get_event_data(['event_number','event_area'], event_range=event_range)
        
   
    start,end = event_range['filter']
    duration  = round(end-start)
    
    #---------------------------------------------------------------------------
    # Prepare the plot and do it.
    #---------------------------------------------------------------------------  
    # initilize a dict to store the event counts and get the total number
    # of events.
    cum_num = {}
    total_events   = len(event_data['event_number']) 
        
    for num in range(total_events):
        area = float(sorted(event_data['event_area'])[num])*float(pow(10,-6))
        cum_num[area] = total_events - (num + 1)

    sys.stdout.write("\nnumber of events  : {}\n".format(total_events))
    
    # dump the counts into x and y arrays for plotting. also, divide the count
    # by the number of years so we get count per year.
    x = []
    y = []
    for area in sorted(iter(cum_num)):
        x.append(float(area))
        y.append(float(cum_num[area]))
        
    # create the line for b = 1
    x_b1 = np.linspace(min(x),max(x),num=1000)
    y_b1 = y[0]*x_b1[0]*(np.array(x_b1)**-1)
    #sys.stdout.write(str(y_b1))
       
    plt.title('Duration: {} years    Total events: {}'.format(duration,total_events))
       
    plt.plot(x_b1,y_b1,label='b=1',ls='-',lw=2,c='r')  
    plt.plot(x,y,'.',c='k')
    plt.legend(loc='upper right')  
    plt.ylabel(r'$N (\geq A_r)$')
    plt.xlabel(r'$A_r [km^2]$')
    plt.xlim(-500,5500)
    plt.ylim(-20,750)
    plt.savefig(output_file,dpi=200)
       
    # do the standard plot
    """vcplotutils.standard_plot(output_file, x, y,
コード例 #3
0
ファイル: test_plot.py プロジェクト: kwschultz/VQScripts
def get_field(evnum,sim_file,field_type='gravity',mag=False,avg_slip=False,
              num_secs=False,num_elem=False):
    from pyvc import *
    from operator import itemgetter
    from pyvc import vcplots
    import sys
    
    output_directory        = 'animation_test_g/'
    field_values_directory  = '{}field_values/'.format(output_directory)
    
    padding   = 0.01
    cutoff    = None

    with VCSimData() as sim_data:
        sim_data.open_file(sim_file)    
        events              = VCEvents(sim_data)
        geometry            = VCGeometry(sim_data)
        min_lat             = geometry.min_lat
        max_lat             = geometry.max_lat
        min_lon             = geometry.min_lon
        max_lon             = geometry.max_lon
        base_lat            = geometry.base_lat
        base_lon            = geometry.base_lon
        event_data          = events[evnum]
        event_element_slips = events.get_event_element_slips(evnum)
        event_sections      = geometry.sections_with_elements(event_element_slips.keys())
                
        if field_type=='gravity':
            EF = vcplots.VCGravityField(min_lat, max_lat, min_lon, max_lon, base_lat, base_lon, padding=padding)
        else:
            EF = vcplots.VCDisplacementField(min_lat, max_lat, min_lon, max_lon, base_lat, base_lon, padding=padding)
                
        field_values_loaded = EF.load_field_values('{}{}_'.format(field_values_directory, evnum))
        
    
        if field_values_loaded:
            sys.stdout.write('loaded'.format(evnum))
            # If they havent been saved then we need to calculate them
        elif not field_values_loaded:
            sys.stdout.write('processing '.format(evnum))
            sys.stdout.flush()
                        
            ele_getter = itemgetter(*event_element_slips.keys())
            event_element_data = ele_getter(geometry)
            if len(event_element_slips) == 1:
                event_element_data = [event_element_data]
                        
            sys.stdout.write('{} elements :: '.format(len(event_element_slips)))
            sys.stdout.flush()
                        
            EF.calculate_field_values(
                                      event_element_data,
                                      event_element_slips,
                                      cutoff=cutoff,
                                      save_file_prefix='{}{}_'.format(field_values_directory, evnum)
                                      )
    
    '{} elements in {} sections : '.format(len(event_element_slips), len(event_sections))
    
    
    if mag or avg_slip or num_secs or num_elem:
        returning = []
        returning.append(EF)
        if mag:
            returning.append(event_data[3])
        if avg_slip:
            returning.append(event_data[13])
        if num_secs:
            returning.append(len(event_element_slips))
        if num_elem:
            returning.append(len(event_sections))
        
        return returning
    else:
        return EF