def test_sparse_identity(self):
        N = 1000
        A = scipy.sparse.eye(N, N)
        b = np.random.rand(N)

        try:
            x = solve_sparse_system(A, b)
        except AttributeError:
            # Deal with older scipy versions that do not have spilu module
            x = solve_sparse_system(A, b, preconditioner_type='diagonal')

        np.testing.assert_array_equal(b, x)
    def test_sparse_identity ( self ):
        N = 1000;
        A = scipy.sparse.eye ( N, N )
        b = np.random.rand ( N )

        try:
            x = solve_sparse_system ( A, b )
        except AttributeError:
            # Deal with older scipy versions that do not have spilu module
            x = solve_sparse_system ( A, b, preconditioner_type='diagonal')
        
        np.testing.assert_array_equal( b, x )
Beispiel #3
0
dp.set_material_regions(materials)
dp.set_region_meshfunction(material_mesh_func)
dp.set_boundary_conditions(bcs)
current_sources = sucemfem.Sources.current_source.CurrentSources()
dipole_source = point_source.PointCurrentSource()
dipole_source.set_position(source_coord)
dipole_source.set_value(source_value)
current_sources.add_source(dipole_source)
dp.set_sources(current_sources)
dp.init_problem()
dp.set_frequency(freq)

A = dp.get_LHS_matrix()
b = dp.get_RHS()
print 'solve using scipy bicgstab'
x = solve_sparse_system(A, b, preconditioner_type='diagonal')

recon = Reconstruct(dp.function_space)
recon.set_dof_values(x)
E_field = recon.reconstruct_points(field_pts)

r1 = field_pts[:] / lam
x1 = r1[:, 0]
E_ana = N.abs(analytical_result)
E_num = E_field
figure()
plot(x1, N.abs(E_num[:, 0]), '-g', label='x_num')
plot(x1, N.abs(E_num[:, 1]), '-b', label='y_num')
plot(x1, N.abs(E_num[:, 2]), '-r', label='z_num')
plot(analytical_pts, E_ana, '--r', label='z_ana')
ylabel('E-field Magnitude')
Beispiel #4
0
dp.set_material_regions(materials)
dp.set_region_meshfunction(material_mesh_func)
dp.set_boundary_conditions(bcs)
current_sources = sucemfem.Sources.current_source.CurrentSources()
dipole_source = point_source.PointCurrentSource()
dipole_source.set_position(source_coord)
dipole_source.set_value(source_value)
current_sources.add_source(dipole_source)
dp.set_sources(current_sources)
dp.init_problem()
dp.set_frequency(freq)

A = dp.get_LHS_matrix()
b = dp.get_RHS()
print "solve using scipy bicgstab"
x = solve_sparse_system(A, b, preconditioner_type="diagonal")

recon = Reconstruct(dp.function_space)
recon.set_dof_values(x)
E_field = recon.reconstruct_points(field_pts)

r1 = field_pts[:] / lam
x1 = r1[:, 0]
E_ana = N.abs(analytical_result)
E_num = E_field
figure()
plot(x1, N.abs(E_num[:, 0]), "-g", label="x_num")
plot(x1, N.abs(E_num[:, 1]), "-b", label="y_num")
plot(x1, N.abs(E_num[:, 2]), "-r", label="z_num")
plot(analytical_pts, E_ana, "--r", label="z_ana")
ylabel("E-field Magnitude")
    
    F_sp = dolfin_ublassparse_to_scipy_csr ( F ) # scipy.sparse.csr_matrix ( F.array() )
    C_sp = scipy.sparse.csr_matrix ( N.dot(C, N.diag(coefficients_C)) )

#    LHS[num_ports*M:,num_ports*M:] = F.array()[:,:]
#    LHS[num_ports*M:,:num_ports*M] = N.dot(C, N.diag(coefficients_C))
    LHS = scipy.sparse.vstack( ( AD, scipy.sparse.hstack( (C_sp, F_sp ), 'csr') ), 'csr' )
    
    RHS[0,0] = -LHS[0,0]
    RHS[num_ports*M:,0] = coefficient_H_C*H_inc.array()[:]
    t.stop()
    
    print "Solving (sparse)"
    t = Timer("Sparse Solve")
    
    BE = solve_sparse_system (LHS, RHS)

    t.stop()
    print "Done"
    
    results[0,i] = f
    
    for k in range(num_ports):
        for m in range(M):
            results[1+k*M+m,i] = BE[k*M+m] 
    
#    print BE[:num_ports*M]

S11 = results[1+0*M,:]
S21 = results[1+1*M,:]
Beispiel #6
0
        F)  # scipy.sparse.csr_matrix ( F.array() )
    C_sp = scipy.sparse.csr_matrix(N.dot(C, N.diag(coefficients_C)))

    #    LHS[num_ports*M:,num_ports*M:] = F.array()[:,:]
    #    LHS[num_ports*M:,:num_ports*M] = N.dot(C, N.diag(coefficients_C))
    LHS = scipy.sparse.vstack((AD, scipy.sparse.hstack((C_sp, F_sp), 'csr')),
                              'csr')

    RHS[0, 0] = -LHS[0, 0]
    RHS[num_ports * M:, 0] = coefficient_H_C * H_inc.array()[:]
    t.stop()

    print "Solving (sparse)"
    t = Timer("Sparse Solve")

    BE = solve_sparse_system(LHS, RHS)

    t.stop()
    print "Done"

    results[0, i] = f

    for k in range(num_ports):
        for m in range(M):
            results[1 + k * M + m, i] = BE[k * M + m]

#    print BE[:num_ports*M]

S11 = results[1 + 0 * M, :]
S21 = results[1 + 1 * M, :]