Exemplo n.º 1
0
def calc_Vsh_l(A, lm1_sqrt, sanity_checks=False):    
    D = A.shape[2]
    Dm1 = A.shape[1]
    q = A.shape[0]
    
    if q * Dm1 - D <= 0:
        return None
    
    L = sp.zeros((D, q, Dm1), dtype=A.dtype, order='C')

    for s in xrange(q):
        L[:,s,:] = lm1_sqrt.dot(A[s]).conj().T

    L = L.reshape((D, q * Dm1))
    V = ns.nullspace_qr(L)

    if sanity_checks:
        if not sp.allclose(L.dot(V), 0):
            log.warning("Sanity Fail in calc_Vsh_l!: LV != 0")
        if not sp.allclose(V.conj().T.dot(V), sp.eye(V.shape[1])):
            log.warning("Sanity Fail in calc_Vsh_l!: V H(V) != eye")
        
    V = V.reshape((q, Dm1, q * Dm1 - D))

    Vsh = sp.transpose(V.conj(), axes=(0, 2, 1))
    Vsh = sp.asarray(Vsh, order='C')

    if sanity_checks:
        M = eps_l_noop(lm1_sqrt, A, V)
        if not sp.allclose(M, 0):
            log.warning("Sanity Fail in calc_Vsh_l!: Bad Vsh")

    return Vsh
Exemplo n.º 2
0
    def test1_read_excel_curve_data(self):
        dirs = determine_this_file_path()
        excel_file = 'synthetic_data_Flood_2012.xls'
        excel_file = os.path.join(dirs, excel_file)
        temp = create_vuln_xml.read_excel_curve_data(excel_file)
        depths, fab, contents = temp

        self.assertTrue(allclose(depths, array([0., 1.0])))

        actually_fab = {u'FCM1_INSURED': array([0., 0.1]),
                        u'FCM2_INSURED': array([0., 0.12]),
                        u'FCM1_UNINSURED': array([0., 0.5]),
                        u'FCM2_UNINSURED': array([0., 0.52])}
        act_cont = {
            u'FCM1_INSURED_SAVE': array([0., 0.2]),
            u'FCM1_INSURED_NOACTION': array([0., 0.3]),
            u'FCM1_INSURED_EXPOSE': array([0., 0.4]),
            u'FCM1_UNINSURED_SAVE': array([0., 0.6]),
            u'FCM1_UNINSURED_NOACTION': array([0., 0.7]),
            u'FCM1_UNINSURED_EXPOSE': array([0., 0.8]),
            u'FCM2_INSURED_SAVE': array([0., 0.22]),
            u'FCM2_INSURED_NOACTION': array([0., 0.32]),
            u'FCM2_INSURED_EXPOSE': array([0., 0.42]),
            u'FCM2_UNINSURED_SAVE': array([0., 0.62]),
            u'FCM2_UNINSURED_NOACTION': array([0., 0.72]),
            u'FCM2_UNINSURED_EXPOSE': array([0., 0.82])
        }

        for key in actually_fab:
            self.assertTrue(allclose(actually_fab[key], fab[key]))

        for key in act_cont:
            self.assertTrue(allclose(act_cont[key], contents[key]))
Exemplo n.º 3
0
    def test_outside_polygon(self):
        U = [[0,0], [1,0], [1,1], [0,1]] #Unit square    

        assert not is_outside_polygon( [0.5, 0.5], U )
        #evaluate to False as the point 0.5, 0.5 is inside the unit square
        
        assert is_outside_polygon( [1.5, 0.5], U )
        #evaluate to True as the point 1.5, 0.5 is outside the unit square
        
        indices = outside_polygon( [[0.5, 0.5], [1, -0.5], [0.3, 0.2]], U )
        assert allclose( indices, [1] )
        
        #One more test of vector formulation returning indices
        polygon = [[0,0], [1,0], [0.5,-1], [2, -1], [2,1], [0,1]]
	points = [ [0.5, 0.5], [1, -0.5], [1.5, 0], [0.5, 1.5], [0.5, -0.5]]
	res = outside_polygon( points, polygon )

	assert allclose( res, [3, 4] )



        polygon = [[0,0], [1,0], [0.5,-1], [2, -1], [2,1], [0,1]]
	points = [ [0.5, 1.4], [0.5, 0.5], [1, -0.5], [1.5, 0], [0.5, 1.5], [0.5, -0.5]]
	res = outside_polygon( points, polygon )

	assert allclose( res, [0, 4, 5] )        
Exemplo n.º 4
0
 def test_gets_axes_right(self):
     Map = tools.set_up_map(self.Data, (0.0, 5.2), (45, 23), (0.4, 0.5))
     Map.calc_axes()
     self.Data.calc_freq()
     self.assertTrue(sp.allclose(Map.freq, self.Data.freq))
     self.assertTrue(sp.allclose(Map.long, tools.calc_bins(0.0, 45, 0.4, "middle")))
     self.assertTrue(sp.allclose(Map.lat, tools.calc_bins(5.2, 23, 0.5, "middle")))
 def test_rigged_pointing(self) :
     Data = self.blocks[0]
     Data.calc_freq()
     map = self.map
     # Set all data = (f + cal_ind)*time_ind
     Data.data[:,:,:,:] = (sp.arange(-4.5, 5)
                           [:,sp.newaxis,sp.newaxis,sp.newaxis]
                           *(Data.freq/100e6))
     Data.data[...] -= sp.mean(Data.data, 0)
     Data.data[...] += (sp.arange(6,8).reshape((1,1,2,1)) * (Data.freq/100e6) 
                        * sp.arange(-4.5, 5).reshape((10, 1, 1, 1)))
     map[:,:,:] = 0.0
     # Set 10 pixels to match data (except for cal_ind part).
     map[:, range(10), range(10)] = (sp.arange(-4.5, 5)[None,:]
                                     * map.get_axis('freq')[:,None]/100e6)
     # We should be completely insensitive to the map mean.  Th following
     # should have no effect.
     map[...] += 0.352*map.get_axis('freq')[:, None, None]/800.0e7
     # Rig the pointing to point to those 10 pixels.
     def rigged_pointing() :
         Data.ra = map.get_axis('ra')[range(10)]
         Data.dec = map.get_axis('dec')[range(10)]
     Data.calc_pointing = rigged_pointing
     smd.sub_map(Data, map)
     # Now data should be just f*time_ind*(cal_ind+6), within 2.0 MHz/2.
     Data.data /= sp.arange(-4.5, 5)[:,sp.newaxis,sp.newaxis,sp.newaxis]
     Data.data /= Data.freq/100e6
     # Relative tol of 1/700, is the frequency bin width.
     self.assertTrue(sp.allclose(Data.data[:,:,0,:], 6.0, rtol=1.0/700))
     self.assertTrue(sp.allclose(Data.data[:,:,1,:], 7.0, rtol=1.0/700))
 def test_correlate(self) :
     Data = self.blocks[0]
     Data.calc_freq()
     map = self.map
     gain = 3.45
     const = 2.14
     # Set all data = gain*(cos(time_ind)).
     Data.data[:,:,:,:] = gain*sp.cos(sp.arange(1,11)
                                 [:,sp.newaxis,sp.newaxis,sp.newaxis])
     # Explicitly set time mean to something known.
     Data.data -= ma.mean(Data.data, 0)
     Data.data += gain*const*Data.freq/800.0e6
     # Now the Map.
     map[:,:,:] = 0.0
     # Set 10 pixels to match cos part of data.
     map[:, range(10), range(10)] = (
                 sp.cos(sp.arange(1,11)[None, :]))
     map[:, range(10), range(10)] -= ma.mean(
         map[:, range(10), range(10)], 1)[:, None]
     # Give Map a mean to test things out. Should really have no effect.
     map[...] += 0.352*map.get_axis('freq')[:, None, None]/800.0e6
     # Rig the pointing to point to those 10 pixels.
     def rigged_pointing() :
         Data.ra = map.get_axis('ra')[range(10)]
         Data.dec = map.get_axis('dec')[range(10)]
     Data.calc_pointing = rigged_pointing
     solved_gains = smd.sub_map(Data, map, correlate=True)
     # Now data should be just be gain*const*f, within machine precision.
     Data.data /= gain*Data.freq/800.0e6
     self.assertTrue(sp.allclose(Data.data[:,:,:,:], const))
     self.assertTrue(sp.allclose(solved_gains, gain))
Exemplo n.º 7
0
def calc_Vsh(A, r_s, sanity_checks=False):
    D = A.shape[2]
    Dm1 = A.shape[1]
    q = A.shape[0]
    
    if q * D - Dm1 <= 0:
        return None
    
    R = sp.zeros((D, q, Dm1), dtype=A.dtype, order='C')

    for s in xrange(q):
        R[:,s,:] = r_s.dot(A[s].conj().T)

    R = R.reshape((q * D, Dm1))
    Vconj = ns.nullspace_qr(R.conj().T).T

    if sanity_checks:
        if not sp.allclose(mm.mmul(Vconj.conj(), R), 0):
            log.warning("Sanity Fail in calc_Vsh!: VR != 0")
        if not sp.allclose(mm.mmul(Vconj, Vconj.conj().T), sp.eye(Vconj.shape[0])):
            log.warning("Sanity Fail in calc_Vsh!: V H(V) != eye")
        
    Vconj = Vconj.reshape((q * D - Dm1, D, q))

    Vsh = Vconj.T
    Vsh = sp.asarray(Vsh, order='C')

    if sanity_checks:
        Vs = sp.transpose(Vsh, axes=(0, 2, 1)).conj()
        M = eps_r_noop(r_s, Vs, A)
        if not sp.allclose(M, 0):
            log.warning("Sanity Fail in calc_Vsh!: Bad Vsh")

    return Vsh
Exemplo n.º 8
0
    def test_build_replacement_ratios(self):
        #usage_values_per_struct = ['RES1',
        #                          'RES3', 'COM8', 'GOV1', 'GOV1', 'GOV1']
        usage_values_per_struct = [111, 231, 231]

        rcp_actual = {'structural':[0.2344, 0.1918, 0.1918],
                      'nonstructural drift sensitive':[0.5,0.3288, 0.3288],
                      'nonstructural acceleration sensitive':[0.2656,
                                                              0.4795,
                                                              0.4795
                                                              ]}
        buildings_usage_classification = 'FCB'
        rcp = build_replacement_ratios(usage_values_per_struct,
                                       buildings_usage_classification)
        components = ['structural', 'nonstructural drift sensitive',
        'nonstructural acceleration sensitive']
        for comp in components:
            self.assert_ (allclose(rcp[comp], rcp_actual[comp], 0.001))
            
        usage_values_per_struct = ['RES1', 'COM4', 'COM4']

        rcp_actual = {'structural':[0.2344, 0.1918, 0.1918],
                      'nonstructural drift sensitive':[0.5,0.3288, 0.3288],
                      'nonstructural acceleration sensitive':[0.2656,
                                                              0.4795,
                                                              0.4795
                                                              ]}
        buildings_usage_classification = 'HAZUS'
        rcp = build_replacement_ratios(usage_values_per_struct,
                                       buildings_usage_classification)
        components = ['structural', 'nonstructural drift sensitive',
        'nonstructural acceleration sensitive']
        for comp in components:
            self.assert_ (allclose(rcp[comp], rcp_actual[comp], 0.001))
Exemplo n.º 9
0
    def test_wind_v3_template(self):
        # Test running an end to end cyclone test based
        # on a wind config template.

        # The output file
        f = tempfile.NamedTemporaryFile(
            suffix='.npz',
            prefix='HAZIMPt_wind_scenarios_test_const',
            delete=False)

        wind_dir = os.path.join(misc.EXAMPLE_DIR, 'wind')
        exp_filename = os.path.join(wind_dir,
                                    'syn_small_exposure_tcrm.csv')
        wind_filename = os.path.join(wind_dir, 'gust01.txt')
        a_config = [{TEMPLATE: WINDV3},
                    {LOADCSVEXPOSURE: {'file_name': exp_filename,
                                       'exposure_latitude': 'LATITUDE',
                                       'exposure_longitude': 'LONGITUDE'}},
                    {LOADWINDTCRM: [wind_filename]},
                    {CALCSTRUCTLOSS: {REP_VAL_NAME: 'REPLACEMENT_VALUE'}},
                    {SAVE: f.name}]

        context = hazimp.start(config_list=a_config)

        self.assertTrue(allclose(
            context.exposure_att['structural_loss'],
            context.exposure_att['calced-loss']))

        # Only the head node writes a file
        if parallel.STATE.rank == 0:
            exp_dict = numpy.load(f.name)
            self.assertTrue(allclose(exp_dict['structural_loss'],
                                     exp_dict['calced-loss']))
        os.remove(f.name)
Exemplo n.º 10
0
    def test_lowrank_ard(self):
        
        theta = SP.array(SP.random.randn(1+self.n_train)**2)
        theta_hat = SP.exp(2*theta)

        _K = theta_hat[0]*SP.dot(self.Xtrain,self.Xtrain.T) + SP.diag(theta_hat[1:])
        _Kcross = theta_hat[0]*SP.dot(self.Xtrain,self.Xtest.T)
        _Kgrad_theta = 2*theta_hat[0]*SP.dot(self.Xtrain,self.Xtrain.T)
        
        cov = lowrank.LowRankArdCF(n_dimensions=self.n_dimensions,n_hyperparameters=self.n_train+1)
        cov.X = self.Xtrain
        cov.Xcross = self.Xtest
        K = cov.K(theta)
        Kcross = cov.Kcross(theta)

        assert SP.allclose(K,_K), 'ouch, covariance matrix is wrong'
        assert SP.allclose(Kcross,_Kcross), 'ouch, cross covariance matrix is wrong'
        assert SP.allclose(_Kgrad_theta,cov.Kgrad_theta(theta,0)), 'ouch gradient with respect to theta[0] is wrong'

        # gradient with respect to parameters of the diagonal matrix
        for i in range(self.n_train):
            Kgrad_theta = cov.Kgrad_theta(theta,i+1)
            _Kgrad_theta = SP.zeros(Kgrad_theta.shape)
            _Kgrad_theta[i,i] = 2*theta_hat[i+1]
            assert SP.allclose(Kgrad_theta, _Kgrad_theta), 'ouch gradient with respect to theta[%d] is wrong'%(i+1)
            
        # gradient with respect to latent factors
        for i in range(self.n_dimensions):
            for j in range(self.n_train):
                Xgrad = SP.zeros(self.Xtrain.shape)
                Xgrad[j,i] = 1
                _Kgrad_x =  theta_hat[0]*(SP.dot(Xgrad,self.Xtrain.T) + SP.dot(self.Xtrain,Xgrad.T))
                Kgrad_x = cov.Kgrad_x(theta,i,j)
                assert SP.allclose(Kgrad_x,_Kgrad_x), 'ouch, gradient with respect to x is wrong for entry [%d,%d]'%(i,j)
Exemplo n.º 11
0
    def test_calc_activities_Characteristic(self):
    
    
    ##  As far as I can tell you can regard this function as generating
    ##  events for testing.
        def make_bins(min_mag,max_magnitude,num_bins,
              recurrence_model_dist = 'bounded_gutenberg_richter'):
            if (recurrence_model_dist == 'characteristic'):
                m2=0.5
                m_c=max_magnitude-m2
                
                delta_mag = (m_c-min_mag)/(num_bins)
                bins = r_[min_mag+delta_mag/2:m_c-delta_mag/2:(num_bins)*1j]
                
                characteristic_bin = array([m_c+(m2/2)])
                bins = append(bins,characteristic_bin)
            else:
                delta_mag = (max_magnitude-min_mag)/num_bins
                bins = r_[min_mag+delta_mag/2:max_magnitude-delta_mag/2:num_bins*1j]
            #approximate the number of earthquakes in discrete (0.1 unit) bins
            return bins
    
    
        max_magnitude = 7.0
        min_magnitude = 4.0
        slip_rate_mm = 2.0
        area_kms = float(30*10)
        b = 1.
        prob_number_of_mag_sample_bins = 10
        bin_centroids = make_bins(min_magnitude, max_magnitude,
                                  prob_number_of_mag_sample_bins,
                                  'characteristic')
#        event_bins = r_[0:10]
#        event_bins = sorted(event_bins)
#    
        A_minCharacteristic = calc_A_min_from_slip_rate_Characteristic(
            b, min_magnitude,
            max_magnitude,
            slip_rate_mm, area_kms)
        
        pdfs = calc_activities_Characteristic(bin_centroids, b, 
                                              min_magnitude, 
                                              max_magnitude)
        
#        event_activity_source = array(
#                [(A_minCharacteristic*pdfs[z]/(sum(where(
#                event_bins == z, 1,0)))) for z in event_bins])
        event_activity_source = array(A_minCharacteristic*pdfs)
        self.assert_(allclose(sum(event_activity_source),A_minCharacteristic))
        self.assert_(allclose(event_activity_source,[1.09104980e-02,
                                                     6.13542392e-03,
                                                     3.45020242e-03,
                                                     1.94019140e-03,
                                                     1.09104980e-03,
                                                     6.13542392e-04,
                                                     3.45020242e-04,
                                                     1.94019140e-04,
                                                     1.09104980e-04,
                                                     6.13542392e-05,
                                                     4.60091887e-04]))
Exemplo n.º 12
0
    def test_linear(self):
        theta = SP.array([SP.random.randn()**2])
        theta_hat = SP.exp(2*theta)

        _K = SP.dot(self.Xtrain,self.Xtrain.T)
        _Kcross = SP.dot(self.Xtrain,self.Xtest.T)
        
        cov = linear.LinearCF(n_dimensions=self.n_dimensions)
        cov.X = self.Xtrain
        cov.Xcross = self.Xtest
        
        K = cov.K(theta)
        Kcross = cov.Kcross(theta)
        Kgrad_x = cov.Kgrad_x(theta,0)
        Kgrad_theta = cov.Kgrad_theta(theta,0)
        
        assert SP.allclose(K, theta_hat*_K), 'ouch covariance matrix is wrong'
        assert SP.allclose(Kgrad_theta, 2*theta_hat*_K), 'ouch, gradient with respect to theta is wrong'
        assert SP.allclose(Kcross, theta_hat*_Kcross), 'ouch, cross covariance is wrong'

        # gradient with respect to latent factors
        # for each entry
        for i in range(self.n_dimensions):
            for j in range(self.n_train):
                Xgrad = SP.zeros(self.Xtrain.shape)
                Xgrad[j,i] = 1
                _Kgrad_x =  theta_hat*(SP.dot(Xgrad,self.Xtrain.T) + SP.dot(self.Xtrain,Xgrad.T))
                Kgrad_x = cov.Kgrad_x(theta,i,j)
                assert SP.allclose(Kgrad_x,_Kgrad_x), 'ouch, gradient with respect to x is wrong for entry [%d,%d]'%(i,j)
Exemplo n.º 13
0
    def test_lowrank_iso(self):
        theta = SP.array(SP.random.randn(2)**2)
        theta_hat = SP.exp(2*theta)

        _K = theta_hat[0]*SP.dot(self.Xtrain,self.Xtrain.T) + theta_hat[1]*SP.eye(self.n_train)
        _Kcross = theta_hat[0]*SP.dot(self.Xtrain,self.Xtest.T)
        _Kgrad_theta = []
        _Kgrad_theta.append(2*theta_hat[0]*SP.dot(self.Xtrain,self.Xtrain.T) )
        _Kgrad_theta.append(2*theta_hat[1]*SP.eye(self.n_train))

        cov = lowrank.LowRankCF(self.n_dimensions)
        cov.X = self.Xtrain
        cov.Xcross = self.Xtest
        
        K = cov.K(theta)
        Kcross = cov.Kcross(theta)

        assert SP.allclose(K,_K), 'ouch, covariance matrix is wrong'
        assert SP.allclose(Kcross,_Kcross), 'ouch, cross covariance matrix is wrong'
        assert SP.allclose(_Kgrad_theta[0],cov.Kgrad_theta(theta,0))
        assert SP.allclose(_Kgrad_theta[1],cov.Kgrad_theta(theta,1))

        # gradient with respect to latent factors
        for i in range(self.n_dimensions):
            for j in range(self.n_train):
                Xgrad = SP.zeros(self.Xtrain.shape)
                Xgrad[j,i] = 1
                _Kgrad_x =  theta_hat[0]*(SP.dot(Xgrad,self.Xtrain.T) + SP.dot(self.Xtrain,Xgrad.T))
                Kgrad_x = cov.Kgrad_x(theta,i,j)
                assert SP.allclose(Kgrad_x,_Kgrad_x), 'ouch, gradient with respect to x is wrong for entry [%d,%d]'%(i,j)
Exemplo n.º 14
0
 def test_correlated_scatter(self) :
     n = 50
     r = (sp.arange(n, dtype=float) + 10.0*n)/10.0*n
     data = sp.sin(sp.arange(n)) * r 
     amp = 25.0
     theory = data/amp
     # Generate correlated matrix.
     C = random.rand(n, n) # [0, 1) 
     # Raise to high power to make values near 1 rare.
     C = (C**10) * 0.2
     C = (C + C.T)/2.0
     C += sp.identity(n)
     C *= r[:, None]/2.0
     C *= r[None, :]/2.0
     # Generate random numbers in diagonal frame.
     h, R = linalg.eigh(C)
     self.assertTrue(sp.alltrue(h>0))
     rand_vals = random.normal(size=n)*sp.sqrt(h)
     # Rotate back.
     data += sp.dot(R.T, rand_vals)
     out = utils.ampfit(data, C, theory)
     a, s = out['amp'], out['error']
     self.assertTrue(sp.allclose(a, amp, atol=5.0*s, rtol=0))
     # Expect the next line to fail 1/100 trials.
     self.assertFalse(sp.allclose(a, amp, atol=0.01*s, rtol=0))
Exemplo n.º 15
0
    def unnfinished_test_quick_convert_csv_to_arrays_lats_longs_file(self):
        (handle, file_name) = tempfile.mkstemp('.csv', 'test_csv_interface_')
        os.close(handle)
        
        LONGITUDE = [11.5, 11.6, 11.7, 11.8]
        LATITUDE = [-3.1, -3.2, -3.3, -3.4]
        WALLS = ['Brick veneer', 'Double Brick', 'Fibro', 'Double Brick']
        
        attribute_dic = {'LONGITUDE': LONGITUDE,
                         'LATITUDE': LATITUDE,
                         'WALLS': WALLS}
        title_index_dic = {'LONGITUDE': 0,
                           'LATITUDE': 1,
                           'WALLS': 2}
        util.dict2csv(file_name, title_index_dic, attribute_dic)
        print "file_name", file_name
        lon = csvi.quick_convert_csv_to_arrays(file_name, LONGITUDE=float)
        assert lon.keys()[0] == 'LONGITUDE'
        assert len(lon.keys()) == 1
        assert scipy.allclose(LONGITUDE, lon['LONGITUDE'])
        
        all_conversions = {'LONGITUDE': float,
                           'LATITUDE': float,
                           'WALLS': str}

        all = csvi.quick_convert_csv_to_arrays(self.dummy_f, **all_conversions)
        assert len(all.keys()) == 3
        assert scipy.allclose(LATITUDE, all['LATITUDE'])
        assert scipy.allclose(LONGITUDE, all['LONGITUDE'])
        assert scipy.allclose(self.WALLS == all['WALLS'])

        os.remove(file_name)
Exemplo n.º 16
0
 def restore_LCF(self, use_QR=True, update_r=True, diag_r=True):
     """Use a gauge-transformation to restore left canonical form.
     
     See restore_RCF.
     """
     if use_QR:
         tm.restore_LCF_l_seq(self.A, self.l, sanity_checks=self.sanity_checks,
                                  sc_data="restore_LCF_l")
     else:
         G = sp.eye(self.D[0], dtype=self.typ) #This is actually just the number 1
         for n in xrange(1, self.N + 1):
             self.l[n], G, Gi = tm.restore_LCF_l(self.A[n], self.l[n - 1], G,
                                                 zero_tol=self.zero_tol,
                                                 sanity_checks=self.sanity_checks)
     
     if self.sanity_checks:
         lN = tm.eps_l_noop(self.l[self.N - 1], self.A[self.N], self.A[self.N])
         if not sp.allclose(lN, 1, atol=1E-12, rtol=1E-12):
             log.warning("Sanity Fail in restore_LCF!: l_N is bad / norm failure")
     
     if diag_r:
         tm.restore_LCF_r_seq(self.A, self.r, sanity_checks=self.sanity_checks,
                                              sc_data="restore_LCF_r")
 
         if self.sanity_checks:
             if not sp.allclose(self.r[0].A, 1, atol=1E-12, rtol=1E-12):
                 log.warning("Sanity Fail in restore_LCF!: r_0 is bad / norm failure")
                 log.warning("r_0 = %s", self.r[0].squeeze().real)
             
             for n in xrange(1, self.N + 1):
                 l = tm.eps_l_noop(self.l[n - 1], self.A[n], self.A[n])
                 if not sp.allclose(l, self.l[n], atol=1E-11, rtol=1E-11):
                     log.warning("Sanity Fail in restore_LCF!: l_%u is bad (off by %g)", n, la.norm(l - self.l[n]))
     elif update_r:
         self.calc_r()
Exemplo n.º 17
0
 def check_RCF(self):
     """Tests for right canonical form.
     
     Uses the criteria listed in sub-section 3.1, theorem 1 of arXiv:quant-ph/0608197v2.
     
     This is a consistency check mainly intended for debugging purposes.
     
     FIXME: The tolerances appear to be too tight!
     
     Returns
     -------
     (rnsOK, ls_trOK, ls_pos, ls_diag, normOK) : tuple of bool
         rnsOK: Right orthonormalization is fullfilled (self.r[n] = eye)
         ls_trOK: all self.l[n] have trace 1
         ls_pos: all self.l[n] are positive-definite
         ls_diag: all self.l[n] are diagonal
         normOK: the state it normalized
     """
     rnsOK = True
     ls_trOK = True
     ls_herm = True
     ls_pos = True
     ls_diag = True
     
     for n in xrange(1, self.N + 1):
         rnsOK = rnsOK and sp.allclose(self.r[n], sp.eye(self.r[n].shape[0]), atol=self.eps*2, rtol=0)
         ls_herm = ls_herm and sp.allclose(self.l[n] - m.H(self.l[n]), 0, atol=self.eps*2)
         ls_trOK = ls_trOK and sp.allclose(sp.trace(self.l[n]), 1, atol=self.eps*1000, rtol=0)
         ls_pos = ls_pos and all(la.eigvalsh(self.l[n]) > 0)
         ls_diag = ls_diag and sp.allclose(self.l[n], sp.diag(self.l[n].diagonal()))
     
     normOK = sp.allclose(self.l[self.N], 1., atol=self.eps*1000, rtol=0)
     
     return (rnsOK, ls_trOK, ls_pos, ls_diag, normOK)
Exemplo n.º 18
0
 def test_fold_point(self):
     self.assertTrue(
         scipy.allclose(fold_point([0., -0.5, 0.5], lattice=self.rec_latt),
                        self.rec_latt.get_cartesian_coords([0., 0.5, 0.5])))
     self.assertTrue(
         scipy.allclose(fold_point([0.1, -0.6, 0.2], lattice=self.rec_latt),
                        self.rec_latt.get_cartesian_coords([0.1, 0.4, 0.2])))
Exemplo n.º 19
0
 def test_apply_threshold_distance_partial(self):
     """
     Test apply_threshold_distance function for atten_threshold_distance 
     scenario where apply_threshold_distance sets some SA figures to zero
     """
     # Use the ones array for the initial SA figures
     bedrock_SA = self.SA_ones.copy()
     soil_SA = self.SA_ones.copy()
     
     # Set a normal threshold distance
     #                event 0       event 1
     # distances [[   337.69538742  27105.63126916]]
     atten_threshold_distance = 400
     
     # Set up SA arrays that match the expected outcome, noting the distances
     # in the comment above
     site_inds = [0]
     event_inds = [1]
     bedrock_SA_expected = bedrock_SA.copy()
     bedrock_SA_expected[...,site_inds,event_inds,:] = 0
     soil_SA_expected = soil_SA.copy()
     soil_SA_expected[...,site_inds,event_inds,:] = 0
     
     # Run the threshold distance function
     apply_threshold_distance(bedrock_SA,
                              soil_SA,
                              self.sites,
                              atten_threshold_distance,
                              self.use_amplification,
                              self.event_set)
     
     assert allclose(bedrock_SA, bedrock_SA_expected)
     assert allclose(soil_SA, soil_SA_expected)
Exemplo n.º 20
0
    def test_calc_annloss_deagg_grid(self):
        # See documentation/annualised_loss_calc.xls
        # for the calculations of the expected values.

        lat = scipy.array([-25, -24])
        lon = scipy.array([130, 132])
        total_building_loss = scipy.array([[2000.0,    5.0],
                                           [  10.0, 2001.0]])

        total_building_value = scipy.array([2020.0, 2030.0])

        event_activity = scipy.array([0.01, 0.001])
        bins = (1,2)
        percent_ann_loss, lat_lon, _, _ = ca.calc_annloss_deagg_grid(
            lat,
            lon,
            total_building_loss,
            total_building_value,
            event_activity,
            bins=bins)
        
        expected_loss = scipy.array([[0.049233, 0.491135]])
        expected_lat_lon = scipy.array([[-24.5,130.5],[-24.5,131.5]])
        #print "percent_ann_loss", percent_ann_loss
        #print "expected_loss", expected_loss
        self.failUnless(scipy.allclose(percent_ann_loss, expected_loss))
        self.failUnless(scipy.allclose(lat_lon, expected_lat_lon))
Exemplo n.º 21
0
    def test_small_checkable(self):       
        # See documentation/annualised_loss_calc.xls
        # for the calculations of the expected values.
        
        saved_ecloss = [[2000.0,    5.0],
                        [  10.0, 2001.0]]

        saved_ecbval2 = [2020.0, 2030.0]

        nu = [0.01, 0.001]
        
        expected_ann_loss = scipy.array([19.95996, 0.4928386])

        expected_cum_ann_loss = scipy.array([
            [1000, 90.909090],
            [19.95996, 0.0],
            [0.4928386, 0.0]])
        # call function
        (ann_loss,
         cum_ann_loss) = ca.calc_annloss(saved_ecloss, saved_ecbval2, nu)
        
        #print('expected_ann_loss=%s' % str(expected_ann_loss))
        #print('ann_loss=%s' % str(ann_loss))
        #print('cum_ann_loss=%s' % str(cum_ann_loss))
        
        # test return values
        self.failUnless(scipy.allclose(ann_loss, expected_ann_loss))
        self.failUnless(scipy.allclose(cum_ann_loss, expected_cum_ann_loss))
Exemplo n.º 22
0
 def test_few_masked(self):
     Blocks = self.make_blocks()
     for Data in Blocks:
         Data.data[:,:,:,6] = ma.masked
         Data.data[:,:,:,13] = ma.masked
     model_name = 'freq_modes_over_f_' + str(3)
     parameters = mn.measure_noise_parameters(Blocks, [model_name])
     for pol, pol_params in parameters.iteritems():
         for ii in range(3):
             mode_noise = pol_params[model_name]['over_f_mode_' + str(ii)]
             #self.assertTrue(sp.allclose(mode_noise['thermal'], self.dt,
             #                            rtol=0.5))
             self.assertTrue(sp.allclose(mode_noise['mode'][6], 0,
                                         atol=1.e-10))
             self.assertTrue(sp.allclose(mode_noise['mode'][13], 0,
                                         atol=1.e-10))
         expected = sp.ones(self.nf, dtype=float) * self.dt
         expected[6] = T_infinity**2
         expected[13] = T_infinity**2
         thermal = pol_params[model_name]['thermal']
         # weak test since the above modes may have favoured a few channels.
         #print thermal, expected
         self.assertTrue(sp.allclose(thermal, expected, rtol=0.8))
         measured_general_ind = pol_params[model_name]['all_channel_index']
         measured_corner = pol_params[model_name]['all_channel_corner_f']
         self.assertTrue(measured_corner < 4. / self.dt / self.nt / self.nb)
Exemplo n.º 23
0
 def test_fit_over_f_plus_const(self):
     dt = 0.13
     n_time = 10000
     amp = 0.67 # K**2/Hz
     index = -1.3
     f_0 = 1.0
     thermal = 2.7 # K**2/Hz
     BW = 1./dt/2
     window = sig.get_window('hanning', n_time)
     n_spec = 10
     p = 0
     for ii in range(n_spec):
         time_stream = noise_power.generate_overf_noise(amp, index, f_0,
                                                             dt, n_time)
         time_stream += rand.normal(size=n_time) * sp.sqrt(thermal * BW * 2)
         time_stream -= sp.mean(time_stream)
         time_stream *= window
         p += noise_power.calculate_power(time_stream)
     p /= n_spec
     p = noise_power.make_power_physical_units(p, dt)
     w = noise_power.calculate_power(window)
     w_norm = sp.mean(w).real
     #w /= w_norm
     p = noise_power.prune_power(p).real
     #p /= w_norm
     f = noise_power.ps_freq_axis(dt, n_time)
     p = p[1:]
     f = f[1:]
     amp_m, index_m, f0_m, thermal_m = mn.fit_overf_const(p, w, f)
     self.assertTrue(sp.allclose(amp_m, amp, atol=0.2))
     self.assertTrue(sp.allclose(index_m, index, atol=0.1))
     self.assertTrue(sp.allclose(thermal_m, thermal, atol=0.1))
Exemplo n.º 24
0
    def testing(self):
        attributes = {"mo": array(["money", "soup"]), "SITE_CLASS": array(["E", "C"])}
        latitude = [10, 20]
        longitude = [1, 2]
        sites = Sites(latitude, longitude, **attributes)
        site_class2Vs30 = {"C": 30, "E": 40}
        sites.set_Vs30(site_class2Vs30)

        actual = array(latitude)
        self.assert_(allclose(sites.latitude, actual, 0.001))
        actual = array(longitude)
        self.assert_(allclose(sites.longitude, actual, 0.001))
        actual = array(["money", "soup"])
        for (att, act) in map(None, sites.attributes["mo"], actual):
            self.assert_(att == act)
        actual = array([40, 30])
        self.assert_(allclose(sites.attributes["Vs30"], actual, 0.001))

        site_class2Vs30 = {"C": 30}
        try:
            sites.set_Vs30(site_class2Vs30)
        except KeyError:
            pass
        else:
            self.failUnless(False, "KeyError not raised")
Exemplo n.º 25
0
 def test_gets_thermal_with_correlated(self):
     """Checks that the part of the freq_modes code that compensates the
     thermal for mode subtraction works."""
     self.data *= sp.sqrt(self.bw * 2)  # Makes thermal unity.
     # Need to add something correlated so the modes arn't just the
     # channels.
     correlated_overf = noise_power.generate_overf_noise(1, 
                                 -2, 0.5, self.dt, self.data.shape[0])
     correlated_overf += (rand.normal(size=(self.data.shape[0],))
                          * sp.sqrt((self.bw * 2) * 0.3))
     self.data += correlated_overf[:,None,None,None] / sp.sqrt(self.nf)
     Blocks = self.make_blocks()
     # Mask a channel out completly.
     for Data in Blocks:
         Data.data[:,:,:,3] = ma.masked
     model = 'freq_modes_over_f_4'  # Take out 20% of the thermal power.
     parameters = mn.measure_noise_parameters(Blocks,
                                             [model])
     right_ans = sp.ones(self.nf)
     right_ans[3] = T_infinity**2
     for p in parameters.itervalues():
         pars = p[model]
         thermal = pars['thermal']
         self.assertTrue(sp.allclose(thermal,
                                     right_ans, rtol=0.3))
         mean_thermal = sp.mean(thermal[right_ans==1])
         self.assertTrue(sp.allclose(mean_thermal, 1, rtol=0.05))
         self.assertTrue(sp.allclose(pars['over_f_mode_0']['thermal'],
                                     0.3, atol=0.1))
Exemplo n.º 26
0
def test_gaussian_mixture_generator_replicatability():
    "Test the GaussianMixtureModel generator"
    import tempfile
    fname = tempfile.mktemp()

    N = 1000
    n = 500
    D = 10
    K = 3

    gmm = GaussianMixtureModel.generate(fname, K, D)
    gmm.set_seed(100)
    gmm.save()

    X = gmm.sample(N)
    del gmm

    gmm = GaussianMixtureModel.from_file(fname)
    Y = gmm.sample(N)
    assert(sc.allclose(X, Y))
    del gmm

    gmm = GaussianMixtureModel.from_file(fname)
    Y = gmm.sample(N, n)
    assert(sc.allclose(X[:n], Y))
Exemplo n.º 27
0
    def _LML_covar(self,hyperparams,debugging=False):
        """
        log marginal likelihood
        """
        try:
            KV = self.get_covariances(hyperparams,debugging=debugging)
        except LA.LinAlgError:
            LG.error('linalg exception in _LML_covar')
            return 1E6
        except ValueError:
            LG.error('value error in _LML_covar')
            return 1E6
 
        lml_quad = 0.5*(KV['Ytilde']*KV['UYU']).sum()
        lml_det =  0.5 * SP.log(KV['S']).sum()
        lml_const = 0.5*self.n*self.t*(SP.log(2*SP.pi))
        
        if debugging:
            # do calculation without kronecker tricks and compare
            _lml_quad = 0.5 * (KV['alpha']*KV['Yvec']).sum()
            _lml_det =  SP.log(SP.diag(KV['L'])).sum()
            assert SP.allclose(_lml_quad,lml_quad),  'ouch, quadratic form is wrong in _LMLcovar'
            assert SP.allclose(_lml_det, lml_det), 'ouch, ldet is wrong in _LML_covar'
        
        lml = lml_quad + lml_det + lml_const

        return lml
Exemplo n.º 28
0
 def intersect(self,e,coords=True,actual=True):
     #Returns data about the intersection of self and edge e.
     #if coords, return the intersection as a point or false if intersection DNE. If not coords, return true/false
     #actual is a boolean for whether the intersection must be on both edges or not. 
     AA = sp.array(e.a-self.a)
     proj = sp.dot(self.dir[0],AA)*unit(self.dir[0])
     point = sp.array(self.a+proj)   #One issue with this method is in case of parallel edges, it returns a rather arbitrary point on self.
     if actual:
         #Here the parallels are solved because the erroneous intersections won't be on both lines.
         if self.containsPoint(point) and e.containsPoint(point): 
             if coords: return point
             return True
         return False
     else:
         #Here we have to check that the point is at least colinear with both.
         EAP = sp.array(point-e.a)
         EBP = sp.array(point-e.b)
         SAP = sp.array(point-self.a)
         SBP = sp.array(point-self.b)
         s1 = EAP[0]/EBP[0]
         s2 = SAP[0]/EBP[0]
         if sp.allclose(EAP/EBP,s1,1e-8,0) and sp.allclose(SAP/SBP,s2,1e-8,0):
             if coords: return point
             return True
         return False
Exemplo n.º 29
0
 def test_eps_r_noop_multi(self): 
     r0 = tc.eps_r_noop(tc.eps_r_noop(self.r2, self.A2, self.B2), self.A1, self.B1)
     
     r0_ = tc.eps_r_noop_multi(self.r2, [self.A1, self.A2], [self.B1, self.B2])
     
     self.assertTrue(sp.allclose(r0, r0_))
     
     r0__ = tc.eps_r_noop_multi(self.r2, [self.AA12], [self.BB12])
     
     self.assertTrue(sp.allclose(r0, r0__))
     
     r0C = tc.eps_r_op_2s_C12(self.r2, self.C_A12, self.B1, self.B2)
     r0C_ = tc.eps_r_noop_multi(self.r2, [self.C_A12], [self.B1, self.B2])
     
     self.assertTrue(sp.allclose(r0C, r0C_))
     
     r0C2 = tc.eps_r_op_2s_C12_AA34(self.r2, self.C_A12, self.BB12)
     r0C2_ = tc.eps_r_noop_multi(self.r2, [self.C_A12], [self.BB12])
     
     self.assertTrue(sp.allclose(r0C2, r0C2_))
     
     r0CA2 = tc.eps_r_op_2s_C12(tc.eps_r_noop(self.r2, self.A2, self.B2), 
                                self.C01, self.A0, self.B1)
     r0CA2_ = tc.eps_r_noop_multi(self.r2, [self.C01, self.A2], [self.A0, self.BB12])
     
     self.assertTrue(sp.allclose(r0CA2, r0CA2_))
Exemplo n.º 30
0
    def test_slice_interpolate_linear(self):
        # Construct a 3D array that is a linear function.
        v = self.vect
        a = sp.arange(5)
        a.shape = (5, 1, 1)
        b = sp.arange(2)
        b.shape = (1, 2, 1)
        c = sp.arange(3)
        c.shape = (1, 1, 3)
        v[:, :, :] = a + b + c
        v.set_axis_info('freq', 2, 1)
        v.set_axis_info('a', 1, 1)
        v.set_axis_info('b', 1, 1)

        #### First test the weights.
        # Test input sanitization.
        self.assertRaises(ValueError, v.slice_interpolate_weights, [0, 1], 2.5)

        # Test bounds.
        self.assertRaises(ValueError, v.slice_interpolate_weights, [1, 2],
                          [2.5, 1.5])

        # Test linear interpolations in 1D.
        points, weights = v.slice_interpolate_weights(0, 2.5, 'linear')
        self.assertTrue(sp.allclose(weights, 0.5))
        self.assertTrue(2 in points)
        self.assertTrue(3 in points)

        # Test linear interpolations in multi D.
        points, weights = v.slice_interpolate_weights([0, 1, 2],
                                                      [0.5, 0.5, 1.5],
                                                      'linear')

        self.assertTrue(sp.allclose(weights, 1.0/8))
        self.assertTrue(points.shape == (8, 3))

        points, weights = v.slice_interpolate_weights([0, 1, 2],
                                                      [3, 1, 2],
                                                      'linear')

        self.assertTrue(sp.allclose(weights % 1, 0))

        #### Test linear interpolation on linear function.
        # Test on the grid points.
        self.assertEqual(v.slice_interpolate([0, 1, 2], [3.0, 1.0, 1.0]),
                         3.0 + 1.0 + 1.0)

        # Test in 1D interpoation.
        out = a + c + 0.347
        out.shape = (5, 3)

        self.assertTrue(sp.allclose(out, v.slice_interpolate(1, 0.347,
                                                             'linear')))

        # Test in 2D.
        out = b + 3.14159 + 1.4112
        out.shape = (2,)

        self.assertTrue(sp.allclose(out, v.slice_interpolate([0, 2],
                        [3.14159, 1.4112], 'linear')))
Exemplo n.º 31
0
    def test_build_capacityII(self):
        """
        Test that the capacity is the same as matlabs
        """
        surface_displacement = array([
            0,
            3.77315416609723,
            10.76027112052043,
            19.35492219305678,
            30.15026521648398,
            35.54123657393061,
            34.27393320582447,
            33.24309574336885,
            31.61082700735715,
            30.28033350490522,
            28.99562491669272,
            27.72120498849989,
            26.45537611101864,
            25.14598796310046,
            23.61941589424981,
            22.22764650672691,
            20.81732741591404,
            19.34361135133465,
            17.85074552102223,
            16.37154426563715,
        ])

        surface_displacement.shape = 1, 1, -1

        Ay, Dy, Au, Du = (0.40000000000000, 1.67808144348440, 0.80000000000000,
                          6.71232577393759)
        aa, bb, cc, kappa = (-1.08731273138362, 0.59591863308111,
                             0.80000000000000, 1.000000000000000e-003)
        capacity_parameters = Dy, Ay, Du, Au, aa, bb, cc
        capacity_parameters = array(capacity_parameters)[:, newaxis, newaxis,
                                                         newaxis]
        capacity = calculate_capacity(surface_displacement,
                                      capacity_parameters)

        #out
        capacity_m = [
            0, 0.68522523139676, 0.80000000000000, 0.80000000000000,
            0.80000000000000, 0.80000000000000, 0.80000000000000,
            0.80000000000000, 0.80000000000000, 0.80000000000000,
            0.80000000000000, 0.80000000000000, 0.80000000000000,
            0.80000000000000, 0.80000000000000, 0.80000000000000,
            0.80000000000000, 0.80000000000000, 0.80000000000000, 0.80000000000
        ]

        assert allclose(capacity[0, 0], capacity_m)
Exemplo n.º 32
0
 def test_solve_eig_bad_ind(self):
     # Set all the information in one pixel to nil.
     self.noise_inv[17, 3, 1, ...] = 0
     self.noise_inv[..., 17, 3, 1] = 0
     self.dirty_map = al.partial_dot(self.noise_inv, self.clean_map)
     self.eig()
     new_clean_map, noise_diag = clean_map.solve_from_eig(
         self.noise_evalsinv,
         self.noise_evects,
         self.dirty_map,
         True,
         feedback=0)
     self.clean_map[17, 3, 1] = 0
     self.assertTrue(sp.allclose(new_clean_map, self.clean_map))
Exemplo n.º 33
0
    def test_to_from_file(self):
        """Test that vects and mats can be written to and from file and have
        all thier properties preserved."""
        # For vectors.
        file_io.save('temp.npy', self.vect)
        new_vect = vector.vect_array(file_io.load('temp.npy'))
        self.assertTrue(sp.allclose(self.vect, new_vect))
        self.assertEqual(self.vect.axes, new_vect.axes)

        # For matricies.
        file_io.save('temp.npy', self.mat)
        new_mat = matrix.mat_array(file_io.load('temp.npy'))
        self.assertTrue(sp.allclose(self.mat, new_mat))
        self.assertEqual(self.mat.axes, new_mat.axes)

        # Messing with stuf should raise exceptions.
        new_mat = file_io.load('temp.npy')
        new_mat.info['cols'] = (0, 3)
        self.assertRaises(ValueError, matrix.mat_array, new_mat)

        # Clean up
        os.remove('temp.npy')
        os.remove('temp.npy.meta')
Exemplo n.º 34
0
    def test_partial_dot_mat_vect(self):
        self.mat.shape = (4, 6, 5)
        self.mat.rows = (0, 1)
        self.mat.cols = (2, )
        self.mat.axes = ('x', 'y', 'freq')
        new_vect = dot_products.partial_dot(self.mat, self.vect)
        self.assertEqual(new_vect.shape, (4, 6, 2, 3))
        self.assertEqual(new_vect.axes, ('x', 'y', 'a', 'b'))

        numerical_result = sp.dot(sp.reshape(self.mat, (4 * 6, 5)),
                                  sp.reshape(self.vect, (5, 2 * 3)))

        self.assertTrue(
            sp.allclose(numerical_result.flatten(), new_vect.flatten()))
Exemplo n.º 35
0
    def test_circle_write_read(self):
        map_copy = copy.deepcopy(self.test_map)
        fits_map.write(map_copy, 'temp_testmap.fits', feedback=0)
        read_map = fits_map.read('temp_testmap.fits', feedback=0)
        os.remove('temp_testmap.fits')

        self.assertTrue(sp.allclose(self.test_map.data, read_map.data))
        for field_name in fits_map.fields:
            self.assertTrue(read_map.field.has_key(field_name))
            self.assertAlmostEqual(self.test_map.field[field_name],
                                   read_map.field[field_name])
        # Finally, check the history.
        hist = read_map.history
        self.assertTrue(hist.has_key('000: Created from scratch.'))
Exemplo n.º 36
0
    def test_DLN_no_variability(self):
        # dimensions (2,1,3,4) = 24 elements
        dim = (2,1,3,4)
        count_up = arange(1,24,1)
        log_mean = resize(count_up*10, dim)
        log_sigma = resize(count_up, dim)
        var_method = None
        
        dist = Distribution_Log_Normal(var_method)
        sample_values = dist.sample_for_eqrm(log_mean,log_sigma)

        actual = exp(log_mean)
        self.assert_(allclose(sample_values, actual))
        self.assert_(actual.shape == dim)
Exemplo n.º 37
0
    def test_spawning(self):
        spawn_bins = 2

        dln = GroundMotionDistributionLogNormal(var_method=SPAWN,
                                                atten_spawn_bins=spawn_bins,
                                                n_recurrence_models=1)
        log_mean = ones((1, 1, 3,4))
        log_mean *= 10
        log_sigma = ones((1, 1, 3,4))
        sample_values = dln.ground_motion_sample(log_mean,log_sigma)
        act_SA_0 = ones((1, 1, 1, 1, 3, 4)) * (10 - 2.5)
        act_SA_1 = ones((1, 1, 1, 1, 3, 4)) * (10 + 2.5)
        act_SA = exp(concatenate((act_SA_0, act_SA_1)))
        self.assert_(allclose(act_SA, sample_values))   
Exemplo n.º 38
0
    def test_load_raster(self):
        # Write a file to test
        f = tempfile.NamedTemporaryFile(suffix='.txt',
                                        prefix='HAZIMPtest_jobs',
                                        delete=False,
                                        mode='w+t')
        f.write('exposure_latitude, exposure_longitude, ID, haz_actual\n')
        f.write('8.1, 0.1, 1, 4\n')
        f.write('7.9, 1.5, 2, -9999\n')
        f.write('8.9, 2.9, 3, 6\n')
        f.write('8.9, 3.1, 4, -9999\n')
        f.write('9.9, 2.9, 5, -9999\n')
        f.close()

        inst = JOBS[LOADCSVEXPOSURE]
        con_in = context.Context()
        con_in.exposure_lat = None
        con_in.exposure_long = None
        con_in.exposure_att = {}
        test_kwargs = {'file_name': f.name}
        inst(con_in, **test_kwargs)
        os.remove(f.name)

        # Write a hazard file
        f = tempfile.NamedTemporaryFile(suffix='.aai',
                                        prefix='HAZIMPtest_jobs',
                                        delete=False,
                                        mode='w+t')
        f.write('ncols 3    \r\n')
        f.write('nrows 2 \r\n')
        f.write('xllcorner +0.    \r\n')
        f.write('yllcorner +8. \r\n')
        f.write('cellsize 1    \r\n')
        f.write('NODATA_value -9999 \r\n')
        f.write('1 2 -9999    \r\n')
        f.write('4 5 6 ')
        f.close()
        haz_v = 'haz_v'
        inst = JOBS[LOADRASTER]
        test_kwargs = {'file_list': [f.name], 'attribute_label': haz_v}
        inst(con_in, **test_kwargs)
        the_nans = isnan(con_in.exposure_att[haz_v])
        con_in.exposure_att.loc[the_nans, (haz_v, )] = -9999
        msg = "con_in.exposure_att[haz_v] " + str(con_in.exposure_att[haz_v])
        msg += "\n not = con_in.exposure_att['haz_actual'] " + \
            str(con_in.exposure_att['haz_actual'])
        self.assertTrue(
            allclose(con_in.exposure_att[haz_v],
                     con_in.exposure_att['haz_actual']), msg)
        os.remove(f.name)
Exemplo n.º 39
0
    def test_separate_points_by_polygon(self):
        U = [[0, 0], [1, 0], [1, 1], [0, 1]]  #Unit square

        indices, count = separate_points_by_polygon(
            [[0.5, 0.5], [1, -0.5], [0.3, 0.2]], U)
        assert allclose(indices, [0, 2, 1])
        assert count == 2

        #One more test of vector formulation returning indices
        polygon = [[0, 0], [1, 0], [0.5, -1], [2, -1], [2, 1], [0, 1]]
        points = [[0.5, 0.5], [1, -0.5], [1.5, 0], [0.5, 1.5], [0.5, -0.5]]
        res, count = separate_points_by_polygon(points, polygon)

        assert allclose(res, [0, 1, 2, 4, 3])
        assert count == 3

        polygon = [[0, 0], [1, 0], [0.5, -1], [2, -1], [2, 1], [0, 1]]
        points = [[0.5, 1.4], [0.5, 0.5], [1, -0.5], [1.5, 0], [0.5, 1.5],
                  [0.5, -0.5]]
        res, count = separate_points_by_polygon(points, polygon)

        assert allclose(res, [1, 2, 3, 5, 4, 0])
        assert count == 3
    def __init__(self, ground_motion_model_names, periods, model_weights):
        self.periods = periods

        # Should do this just once, when the para values are first verified.
        # The -ve value means 'the logic tree is not collapsed'
        self.model_weights = asarray(model_weights)
        if not allclose(1, self.model_weights.sum()):
            print 'model_weights,', -self.model_weights
            raise ValueError('abs(self.model_weights) did not sum to 1!')

        self.GM_models = []
        for GM_model_name in ground_motion_model_names:
            self.GM_models.append(
                Ground_motion_calculator(GM_model_name, periods))
Exemplo n.º 41
0
 def test_reassign_phase_regenerate_models(self):
     physmods = OpenPNM.Physics.models
     net = OpenPNM.Network.Cubic(shape=[5, 5, 5])
     geo1 = OpenPNM.Geometry.GenericGeometry(network=net,
                                             pores=net.Ps,
                                             throats=net.Ts)
     geo1['pore.diameter'] = 1
     geo1['throat.diameter'] = 1
     geo1['throat.length'] = 1
     phase1 = OpenPNM.Phases.GenericPhase(network=net)
     phase1['pore.viscosity'] = 1
     phase2 = OpenPNM.Phases.GenericPhase(network=net)
     phase2['pore.viscosity'] = 10
     phys = OpenPNM.Physics.GenericPhysics(network=net,
                                           phase=phase1,
                                           geometry=geo1)
     phys.models.add(propname='throat.hydraulic_conductance',
                     model=physmods.hydraulic_conductance.hagen_poiseuille)
     assert sp.allclose(phys['throat.hydraulic_conductance'], 0.02454369)
     phys.parent_phase = phase2
     assert sp.allclose(phys['throat.hydraulic_conductance'], 0.02454369)
     phys.models.regenerate()
     assert sp.allclose(phys['throat.hydraulic_conductance'], 0.00245437)
Exemplo n.º 42
0
    def test_forecast_fatality(self):
        # This test is bad, since I'm writing it based on the code.

        MMI = array([1, 2, 4., 10., 11.])
        population = ones(MMI.shape)
        beta = 1.0
        theta = 10.0 * e**-2.0
        fatality = forecast_fatality(MMI, population, beta, theta)
        expected = array([0, 0, 0, norm.cdf(2.0), norm.cdf(2.0)])
        #print "expected", expected
        #print "fatality", fatality
        self.failUnless(allclose(expected, fatality))

        MMI = array([5.])
        pop_scaler = 5.0
        population = ones(MMI.shape) * pop_scaler
        beta = 1.0
        theta = 5.0 * e**-2.0
        fatality = forecast_fatality(MMI, population, beta, theta)
        expected = array([pop_scaler * 1.0 / beta * norm.cdf(2.0)])
        #print "expected", expected
        #print "fatality", fatality
        self.failUnless(allclose(expected, fatality))
Exemplo n.º 43
0
 def test_data(self):
     nf = self.Data.dims[-1]
     # Rebin by 3's.
     data = sp.arange(10, dtype=float) * 3.0
     data = data[...,None] * sp.arange(4)
     data = data[...,None] * sp.arange(2)
     data = data[...,None] * sp.arange(nf)
     new_data = sp.arange(3, dtype=float) * 9.0 + 3.0
     new_data = new_data[...,None] * sp.arange(4)
     new_data = new_data[...,None] * sp.arange(2)
     new_data = new_data[...,None] * sp.arange(nf)
     self.Data.data[...] = data
     rebin_time.rebin(self.Data, 3)
     self.assertTrue(sp.allclose(self.Data.data, new_data))
Exemplo n.º 44
0
 def test_washburn_throat_values(self):
     self.water['throat.surface_tension'] = 0.072
     self.water['throat.contact_angle'] = 120
     f = OpenPNM.Physics.models.capillary_pressure.washburn
     self.phys.models.add(propname='throat.capillary_pressure',
                          model=f,
                          surface_tension='throat.surface_tension',
                          contact_angle='throat.contact_angle',
                          throat_diameter='throat.diameter')
     a = 0.14399999999999993
     assert sp.allclose(self.water['throat.capillary_pressure'][0], a)
     self.phys.models.remove('throat.capillary_pressure')
     del self.water['throat.surface_tension']
     del self.water['throat.contact_angle']
Exemplo n.º 45
0
    def __add__(self, other):

        assert self.ells == other.ells
        if scipy.allclose(self.sedges,
                          other.sedges,
                          rtol=1e-04,
                          atol=1e-05,
                          equal_nan=False):
            self.counts += other.counts
            self.weight_tot += other.weight_tot
        else:
            raise ValueError('s-edges are not compatible.')

        return self
Exemplo n.º 46
0
def restore_LCF_r(A, r, Gi, sanity_checks=False):
    if Gi is None:
        x = r
    else:
        x = Gi.dot(r.dot(Gi.conj().T))

    M = eps_r_noop(x, A, A)
    ev, EV = la.eigh(M) #wraps lapack routines, which return eigenvalues in ascending order
    
    if sanity_checks:
        assert np.all(ev == np.sort(ev)), "unexpected eigenvalue ordering"
    
    rm1 = mm.simple_diag_matrix(ev, dtype=A.dtype)
    Gm1 = EV.conj().T

    if Gi is None:
        Gi = EV #for left uniform case
        r = rm1 #for sanity check

    for s in xrange(A.shape[0]):
        A[s] = Gm1.dot(A[s].dot(Gi))

    if sanity_checks:
        rm1_ = eps_r_noop(r, A, A)
        if not sp.allclose(rm1_, rm1, atol=1E-12, rtol=1E-12):
            log.warning("Sanity Fail in restore_LCF_r!: r is bad!")
            log.warning(la.norm(rm1_ - rm1))

    Gm1_i = EV

    if sanity_checks:
        eye = sp.eye(A.shape[1])
        if not sp.allclose(sp.dot(Gm1, Gm1_i), eye,
                           atol=1E-12, rtol=1E-12):
            log.warning("Sanity Fail in restore_LCF_r!: Bad GT! (off by %g)", la.norm(sp.dot(Gm1, Gm1_i) - eye))
            
    return rm1, Gm1, Gm1_i
Exemplo n.º 47
0
    def test_MaximizeLikelihood(self):
        """Tests maximization likelihood.

        Make sure it gives the same value for several starting points."""
        random.seed(1)
        scipy.random.seed(1)

        tl = phydmslib.treelikelihood.TreeLikelihood(self.tree, self.alignment,
                                                     self.model)

        logliks = []
        paramsarrays = []
        for itest in range(3):
            modelparams = self.getModelParams(itest)
            tl.updateParams(modelparams)
            startloglik = tl.loglik
            result = tl.maximizeLikelihood()
            self.assertTrue(
                tl.loglik > startloglik, "no loglik increase: "
                "start = {0}, end = {1}".format(startloglik, tl.loglik))
            for (otherloglik, otherparams) in zip(logliks, paramsarrays):
                self.assertTrue(
                    scipy.allclose(tl.loglik,
                                   otherloglik,
                                   atol=1e-3,
                                   rtol=1e-3),
                    "Large difference in loglik: {0} vs {1}".format(
                        otherloglik, tl.loglik))
                self.assertTrue(
                    scipy.allclose(tl.paramsarray,
                                   otherparams,
                                   atol=1e-2,
                                   rtol=1e-1),
                    "Large difference in paramsarray: {0} vs {1}, {2}".format(
                        otherparams, tl.paramsarray, self.model))
            logliks.append(tl.loglik)
            paramsarrays.append(tl.paramsarray)
Exemplo n.º 48
0
    def test_lowrank_iso(self):
        theta = SP.array(SP.random.randn(2)**2)
        theta_hat = SP.exp(2 * theta)

        _K = theta_hat[0] * SP.dot(
            self.Xtrain, self.Xtrain.T) + theta_hat[1] * SP.eye(self.n_train)
        _Kcross = theta_hat[0] * SP.dot(self.Xtrain, self.Xtest.T)
        _Kgrad_theta = []
        _Kgrad_theta.append(2 * theta_hat[0] *
                            SP.dot(self.Xtrain, self.Xtrain.T))
        _Kgrad_theta.append(2 * theta_hat[1] * SP.eye(self.n_train))

        cov = lowrank.LowRankCF(self.n_dimensions)
        cov.X = self.Xtrain
        cov.Xcross = self.Xtest

        K = cov.K(theta)
        Kcross = cov.Kcross(theta)

        assert SP.allclose(K, _K), 'ouch, covariance matrix is wrong'
        assert SP.allclose(Kcross,
                           _Kcross), 'ouch, cross covariance matrix is wrong'
        assert SP.allclose(_Kgrad_theta[0], cov.Kgrad_theta(theta, 0))
        assert SP.allclose(_Kgrad_theta[1], cov.Kgrad_theta(theta, 1))

        # gradient with respect to latent factors
        for i in range(self.n_dimensions):
            for j in range(self.n_train):
                Xgrad = SP.zeros(self.Xtrain.shape)
                Xgrad[j, i] = 1
                _Kgrad_x = theta_hat[0] * (SP.dot(Xgrad, self.Xtrain.T) +
                                           SP.dot(self.Xtrain, Xgrad.T))
                Kgrad_x = cov.Kgrad_x(theta, i, j)
                assert SP.allclose(
                    Kgrad_x, _Kgrad_x
                ), 'ouch, gradient with respect to x is wrong for entry [%d,%d]' % (
                    i, j)
Exemplo n.º 49
0
    def test_generate_motion_csv(self):
        # Parameters
        output_dir = self.dir
        site_tag = 'ernabella'
        #is_bedrock = False
        soil_amp = False

        # 1. Create and save analysis objects objects
        self.save_analysis_objects(output_dir, site_tag)

        # 2. Run through generate_motion_csv
        output_filenames = generate_motion_csv(output_dir, site_tag, soil_amp)

        expected_ground_motion = asarray([[0, 1, 2], [3, 4, 5], [6, 7, 8],
                                          [9, 10, 11], [12, 13, 14]])
        expected_atten_periods = asarray([0, 1.0, 2.0])

        # 3. Read in generated files
        for gmm_i, filename in enumerate(output_filenames):
            file_h = open(filename, 'r')

            text = file_h.read().splitlines()
            # ditch the comment lines
            text.pop(0)
            text.pop(0)
            text.pop(0)
            text.pop(0)
            text.pop(0)
            # Convert a space separated text line into a numeric float array
            periods_f = array([float(ix) for ix in text[0].split(' ')])
            self.assert_(allclose(periods_f, array(expected_atten_periods)))
            text.pop(0)

            motion_f = array([float(ix) for ix in text[0].split(' ')])
            self.assert_(allclose(motion_f, expected_ground_motion[gmm_i]))

            file_h.close()
Exemplo n.º 50
0
    def _LML_covar(self, hyperparams, debugging=False):
        """
        log marginal likelihood
        """
        self._update_inputs(hyperparams)

        try:
            KV = self.get_covariances(hyperparams, debugging=debugging)
        except LA.LinAlgError:
            pdb.set_trace()
            LG.error('linalg exception in _LML_covar')
            return 1E6

        Si = 1. / KV['Stilde_rc']
        lml_quad = 0.5 * (ravel(KV['UYtildeU_rc'])**2 * Si).sum()
        lml_det = 0.5 * (SP.log(KV['S_s']).sum() * self.n +
                         SP.log(KV['S_o']).sum() * self.t)
        lml_det += 0.5 * SP.log(KV['Stilde_rc']).sum()
        lml_const = 0.5 * self.nt * (SP.log(2 * SP.pi))

        if debugging:
            # do calculation without kronecker tricks and compare
            _lml_quad = 0.5 * (KV['alpha'] * KV['Yvec']).sum()
            _lml_det = SP.log(SP.diag(KV['L'])).sum()
            assert SP.allclose(
                _lml_quad, lml_quad, atol=1E-2,
                rtol=1E-2), 'ouch, quadratic form is wrong: %.2f' % LA.norm(
                    lml_quad, _lml_quad)
            assert SP.allclose(
                _lml_det, lml_det, atol=1E-2,
                rtol=1E-2), 'ouch, ldet is wrong in _LML_covar' % LA.norm(
                    lml_det, _lml_det)

        lml = lml_quad + lml_det + lml_const

        return lml
Exemplo n.º 51
0
    def test_load(self):
        """Test initial load of Bridges object."""

        b = bridges.Bridges.from_csv(self.file_name)

        actual = scipy.array(self.lat)
        b_lat_str = self.pp.pformat(b.latitude)
        actual_str = self.pp.pformat(actual)
        msg = ('b.latitude != actual\n'
               '(%s !=\n%s)' % (b_lat_str, actual_str))
        self.assert_(scipy.allclose(b.latitude, actual, 0.001), msg)

        actual = scipy.array(self.lon)
        b_lon_str = self.pp.pformat(b.longitude)
        actual_str = self.pp.pformat(actual)
        msg = ('b.longitude != actual\n'
               '(%s !=\n%s)' % (b_lon_str, actual_str))
        self.assert_(scipy.allclose(b.longitude, actual, 0.001))

        actual = scipy.array(['E', 'F', 'G', 'D', 'E', 'F', 'G', 'C'])
        for (att, act) in map(None, b.attributes['SITE_CLASS'], actual):
            msg = ('Expected attribute == actual (got %s == %s)' %
                   (str(att), str(act)))
            self.failUnlessEqual(att, act, msg)

        actual = scipy.array([0, 32, 20, 4, 0, 0, 12, 0])
        for (att, act) in map(None, b.attributes['SKEW'], actual):
            msg = ('Expected attribute == actual (got %s == %s)' %
                   (str(att), str(act)))
            self.failUnlessEqual(att, act, msg)

        actual = scipy.array([2, 3, 4, 5, 6, 7, 8, 9])
        for (att, act) in map(None, b.attributes['BID'], actual):
            msg = ('Expected attribute == actual (got %s == %s)' %
                   (str(att), str(act)))
            self.failUnlessEqual(att, act, msg)
Exemplo n.º 52
0
 def test_purcell_throat_values(self):
     self.water['throat.surface_tension'] = 0.072
     self.water['throat.contact_angle'] = 120
     f = OpenPNM.Physics.models.capillary_pressure.purcell
     self.phys.models.add(propname='throat.capillary_pressure',
                          model=f,
                          r_toroid=0.1,
                          surface_tension='throat.surface_tension',
                          contact_angle='throat.contact_angle',
                          throat_diameter='throat.diameter')
     a = 0.26206427646507374
     assert sp.allclose(self.water['throat.capillary_pressure'][0], a)
     self.phys.models.remove('throat.capillary_pressure')
     del self.water['throat.surface_tension']
     del self.water['throat.contact_angle']
Exemplo n.º 53
0
 def test_Strasser_et_al_2010_interface_rup_width(self):
     # 
     Mw = array([4.5, 6.5, 13., 13.])
     area=array([100., 100., 100., 100.])
     dip = array([ 0., 0., 90., 90.])
     fault_width = array([ 15000. , 15000. , 15000., 2.])
     scaling_dic = {'scaling_rule':'Strasser_et_al_2010_interface'}
     
     width = scaling_calc_rup_width(Mw, scaling_dic,
                                    dip, rup_area=area,
                                    max_rup_width=fault_width)
    
     correct = [ 4.983104559705295, 25.089961794654, 4797.334486366892, 2.]
     assert allclose(correct,
                     width)
Exemplo n.º 54
0
 def test_Strasser_et_al_2010_intraslab_rup_width(self):
     # 
     Mw = array([4.5, 6.5, 13., 13.])
     area=array([100., 100., 100., 100.])
     dip = array([ 0., 0., 90., 90.])
     fault_width = array([ 15000. , 15000. , 15000., 2.])
     scaling_dic = {'scaling_rule':'Strasser_et_al_2010_intraslab'}
     
     width = scaling_calc_rup_width(Mw, scaling_dic,
                                    dip, rup_area=area,
                                    max_rup_width=fault_width)
    
     correct = [ 3.499451670283573, 18.03017740859569, 3715.352290971724, 2.]
     assert allclose(correct,
                     width)
Exemplo n.º 55
0
    def test_linear(self):
        theta = SP.array([SP.random.randn()**2])
        theta_hat = SP.exp(2 * theta)

        _K = SP.dot(self.Xtrain, self.Xtrain.T)
        _Kcross = SP.dot(self.Xtrain, self.Xtest.T)

        cov = linear.LinearCF(n_dimensions=self.n_dimensions)
        cov.X = self.Xtrain
        cov.Xcross = self.Xtest

        K = cov.K(theta)
        Kcross = cov.Kcross(theta)
        Kgrad_x = cov.Kgrad_x(theta, 0)
        Kgrad_theta = cov.Kgrad_theta(theta, 0)

        assert SP.allclose(K,
                           theta_hat * _K), 'ouch covariance matrix is wrong'
        assert SP.allclose(Kgrad_theta, 2 * theta_hat *
                           _K), 'ouch, gradient with respect to theta is wrong'
        assert SP.allclose(Kcross, theta_hat *
                           _Kcross), 'ouch, cross covariance is wrong'

        # gradient with respect to latent factors
        # for each entry
        for i in range(self.n_dimensions):
            for j in range(self.n_train):
                Xgrad = SP.zeros(self.Xtrain.shape)
                Xgrad[j, i] = 1
                _Kgrad_x = theta_hat * (SP.dot(Xgrad, self.Xtrain.T) +
                                        SP.dot(self.Xtrain, Xgrad.T))
                Kgrad_x = cov.Kgrad_x(theta, i, j)
                assert SP.allclose(
                    Kgrad_x, _Kgrad_x
                ), 'ouch, gradient with respect to x is wrong for entry [%d,%d]' % (
                    i, j)
Exemplo n.º 56
0
    def test_build_replacement_ratios(self):
        #usage_values_per_struct = ['RES1',
        #                          'RES3', 'COM8', 'GOV1', 'GOV1', 'GOV1']
        usage_values_per_struct = [111, 231, 231]

        rcp_actual = {
            'structural': [0.2344, 0.1918, 0.1918],
            'nonstructural drift sensitive': [0.5, 0.3288, 0.3288],
            'nonstructural acceleration sensitive': [0.2656, 0.4795, 0.4795]
        }
        buildings_usage_classification = 'FCB'
        rcp = build_replacement_ratios(usage_values_per_struct,
                                       buildings_usage_classification)
        components = [
            'structural', 'nonstructural drift sensitive',
            'nonstructural acceleration sensitive'
        ]
        for comp in components:
            self.assert_(allclose(rcp[comp], rcp_actual[comp], 0.001))

        usage_values_per_struct = ['RES1', 'COM4', 'COM4']

        rcp_actual = {
            'structural': [0.2344, 0.1918, 0.1918],
            'nonstructural drift sensitive': [0.5, 0.3288, 0.3288],
            'nonstructural acceleration sensitive': [0.2656, 0.4795, 0.4795]
        }
        buildings_usage_classification = 'HAZUS'
        rcp = build_replacement_ratios(usage_values_per_struct,
                                       buildings_usage_classification)
        components = [
            'structural', 'nonstructural drift sensitive',
            'nonstructural acceleration sensitive'
        ]
        for comp in components:
            self.assert_(allclose(rcp[comp], rcp_actual[comp], 0.001))
Exemplo n.º 57
0
    def check_YNGKP_M0_attributes(self):
        """Make sure `YNGKP_M0` has the expected attribute values."""
        self.assertEqual(self.nsites, self.YNGKP_M0.nsites)

        # make sure Prxy has rows summing to zero
        self.assertFalse(scipy.isnan(self.YNGKP_M0.Pxy).any())
        self.assertFalse(scipy.isinf(self.YNGKP_M0.Pxy).any())
        diag = scipy.eye(N_CODON, dtype='bool')
        self.assertTrue(
            scipy.allclose(0, scipy.sum(self.YNGKP_M0.Pxy[0], axis=1)))
        self.assertTrue(scipy.allclose(0, self.YNGKP_M0.Pxy[0].sum()))
        self.assertTrue((self.YNGKP_M0.Pxy[0][diag] <= 0).all())
        self.assertTrue((self.YNGKP_M0.Pxy[0][~diag] >= 0).all())
        assert self.YNGKP_M0.Pxy.shape == (1, N_CODON, N_CODON)
        for param in self.YNGKP_M0.dPxy:
            assert self.YNGKP_M0.dPxy[param].shape == (1, N_CODON, N_CODON)
            assert self.YNGKP_M0.B[param].shape == (1, N_CODON, N_CODON)
        assert self.YNGKP_M0.Ainv.shape == (1, N_CODON, N_CODON)
        assert self.YNGKP_M0.A.shape == (1, N_CODON, N_CODON)
        assert self.YNGKP_M0.M(0.2).shape == (self.nsites, N_CODON, N_CODON)
        for (pname, value) in self.params.items():
            assert self.YNGKP_M0.dM(
                0.2, pname,
                self.YNGKP_M0.M(0.2)).shape == (self.nsites, N_CODON, N_CODON)
Exemplo n.º 58
0
 def test_transpose_partial_dot(self):
     self.mat.shape = (5, 4, 6)
     self.mat.cols = (1, 2)
     self.mat.rows = (0, )
     self.mat.axes = ('freq', 'x', 'y')
     matT = self.mat.mat_transpose()
     new_vect = algebra.partial_dot(matT, self.vect)
     self.assertEqual(new_vect.shape, (4, 6, 2, 3))
     self.assertEqual(new_vect.axes, ('x', 'y', 'a', 'b'))
     # Reform origional matrix to get same numerical result.
     mat = sp.reshape(self.mat, (5, 4 * 6))
     mat = sp.rollaxis(mat, 1, 0)
     numerical_result = sp.dot(mat, sp.reshape(self.vect, (5, 2 * 3)))
     self.assertTrue(
         sp.allclose(numerical_result.flatten(), new_vect.flatten()))
Exemplo n.º 59
0
 def test_modified_Wells_and_Coppersmith_94_rup_width2(self):
     # 
     Mw = array([4.5, 6.5, 13., 13.])
     area=array([100., 100., 100., 100.])
     dip = array([ 0., 0., 90., 90.])
     fault_width = array([ 15000. , 15000. , 15000., 2.])
     scaling_dic = {'scaling_rule':'modified_Wells_and_Coppersmith_94'}
     
     width = scaling_calc_rup_width(Mw, scaling_dic,
                                    dip, rup_area=area,
                                    max_rup_width=fault_width)
     
     correct = [ 10., 10., 5., 2.]
     assert allclose(correct,
                     width)
Exemplo n.º 60
0
 def compare_attributes(atts1,atts2):
     self.assertEqual(len(atts1.keys()),len(atts2.keys()),"{}".format(nameRun))
     self.assertListEqual(sorted(atts1.keys()),sorted(atts2.keys()),"{}".format(nameRun))
     for item in atts1:
         nequal = True
         if isinstance(atts1[item],numpy.ndarray):
             nequal = sp.logical_not(sp.array_equal(atts1[item],atts2[item]))
         else:
             nequal = atts1[item]!=atts2[item]
         if nequal:
             print("WARNING: {}: not exactly equal, using allclose for {}".format(nameRun,item))
             print(atts1[item],atts2[item])
             allclose = sp.allclose(atts1[item],atts2[item])
             self.assertTrue(allclose,"{}".format(nameRun))
     return