Exemplo n.º 1
0
def compareMedianBalanceVsRegressionGivenGroundTruth(
                list_of_power, 
                num_time_sample=2000,
                origin_time_sample = 0.01,
                delta_time_sample = 0.002,  
                num_point_ricker_wavelet=100, 
                width_parameter_ricker_wavelet=10, 
                noise_level=1,
                initial_exponent_power=2, 
                max_iteration=60, 
                delta_exponent_power_tolerance=1e-12,
                output_directory='/tmp'):
    
    output = collections.namedtuple('compareMedianBalanceVsRegression', 
                                          ['list_median_balance_recovered_power', 
                                           'list_regression_recovered_power',
                                           'data_by_trace_time'
                                           'domain_time_sample']) 
    output.domain_time_sample = math_op.calculateLinearlySpacedValues(origin_time_sample, 
                                                               delta_time_sample, 
                                                               num_time_sample)
    output.data_by_trace_time = get_ricker_data(list_of_power, 
                                         num_time_sample, 
                                         num_point_ricker_wavelet, 
                                         width_parameter_ricker_wavelet, 
                                         output.domain_time_sample, 
                                         noise_level)
    output.list_median_balance_recovered_power = []
    output.list_regression_recovered_power = []
    for power, trace in zip(list_of_power, output.data_by_trace_time):    
                        #median_balance
        normalized_trace = np.squeeze(math_op.divideEachRowByItsMaxAbsValue(np.array([trace])))                       
        median_result = mb.recoverDomainWeightedGainViaMedianBalancing( normalized_trace, 
                        output.domain_time_sample,
                        initial_exponent_power,
                        max_iteration,
                        delta_exponent_power_tolerance,
                        output_directory,
                        print_to_stdout = 0,
                        logging_level=logging.CRITICAL)
        output.list_median_balance_recovered_power.append(median_result.domain_exponent_power)
                        #regression
        output_logloglinear = lll.findDomainPowerViaLogLogLinearRegresstion(
                                                                    np.abs(trace),
                                                                    output.domain_time_sample)
        output.list_regression_recovered_power.append(-output_logloglinear.slope)
    
    l2_median_balance_powers_error = np.linalg.norm(output.list_median_balance_recovered_power - list_of_power)
    l2_regression_powers_error = np.linalg.norm(output.list_regression_recovered_power - list_of_power)
    print 'l2_median_balance_powers_error= %g' % l2_median_balance_powers_error
    print 'l2_regression_powers_error = %g' % l2_regression_powers_error
    print 'l2_median_balance_powers_error / l2_regression_powers_error = %g' % (l2_median_balance_powers_error/l2_regression_powers_error)


    
    return output
Exemplo n.º 2
0
 list_domain_power = np.linspace(domain_power_min,domain_power_max,num_domain_power)
 
 list_semblance =  semb.findListSemblanceForSignalGainedWithListOfDomainPower(
                                                 np.squeeze(trace),
                                                 domain_time_sample,
                                                 list_domain_power)
 output_file_base_name = "%dsemblancevsdomainpower" % trace_index
 plot_helper.plotSemblanceVsDomainPower(list_domain_power,
               list_semblance,
               local_output_directory,
               output_file_base_name,
               figure_output_settings)
 
                     #log log linear fit
 output_logloglinear = lll.findDomainPowerViaLogLogLinearRegresstion(
                                                     np.abs(trace),
                                                     domain_time_sample)                    
 unique_to_function_call_logger = misc.createUniqueToFunctionCallLogger()         
 log_file = local_output_directory + \
            os.path.sep + \
            unique_to_function_call_logger.name + \
            "logloglinear.log"            
 file_console_handler = logging.FileHandler(log_file)
 misc.setupHandlerAndAddToLogger(file_console_handler, unique_to_function_call_logger)                    
 unique_to_function_call_logger.info("slope=%g,intercept=%g,r_value=%g,p_value=%g,std_err=%g" % 
                                     (output_logloglinear.slope,
                                      output_logloglinear.intercept,
                                      output_logloglinear.r_value,
                                      output_logloglinear.p_value,
                                      output_logloglinear.std_err))
 #END FOR