def _getGhostedValues(self, var): """Obtain current ghost values from across processes Returns ------- ndarray Ghosted values """ mesh = var.mesh localNonOverlappingCellIDs = mesh._localNonOverlappingCellIDs ## The following conditional is required because empty indexing is ## not altogether functional. This numpy.empty((0,))[[]] and this ## numpy.empty((0,))[...,[]] both work, but this numpy.empty((3, ## 0))[...,[]] is broken. if var.shape[-1] != 0: s = (Ellipsis, localNonOverlappingCellIDs) else: s = (localNonOverlappingCellIDs, ) nonOverlappingVector = Epetra.Vector(self.domainMap, var[s].ravel()) overlappingVector = Epetra.Vector(self.colMap) overlappingVector.Import(nonOverlappingVector, Epetra.Import(self.colMap, self.domainMap), Epetra.Insert) return numerix.reshape(numerix.asarray(overlappingVector), var.shape)
def solve_linear_problem(self, A, b, x=None, its=1000, tolerance=1e-10): ''' resolve o problema Ax = b input: A: matriz quadrada esparsa do scipy b = termo fonte x: chute inicial its: numero maximo de iteracoes tolerance: tolerancia para o residuo output: res: informa se o residuo foi menor que a tolerancia x2: vetor resposta ''' comm = self._comm n = len(b) std_map = Epetra.Map(n, 0, comm) x2 = Epetra.Vector(std_map) if x: x2[:] = x[:] b2 = Epetra.Vector(std_map) b2[:] = b[:] A2 = Epetra.CrsMatrix(Epetra.Copy, std_map, 7) indices = sp.find(A) A2.InsertGlobalValues(indices[0], indices[1], indices[2]) irr = A2.FillComplete() linearProblem = Epetra.LinearProblem(A2, x2, b2) solver = AztecOO.AztecOO(linearProblem) solver.SetAztecOption(AztecOO.AZ_output, AztecOO.AZ_warnings) # solver.SetParameters(self._params) solver.Iterate(its, tolerance) x2 = np.array(x2) res = solver.ScaledResidual() < tolerance return x2
def get_inverse_by_inds(comm, inds): """ retorna inds da matriz inversa a partir das informacoes (inds) da matriz de entrada """ assert inds[3][0] == inds[3][1] cols = inds[3][1] sz = [cols, cols] A = TrilinosUtils.get_CrsMatrix_by_inds(comm, inds) lines2 = np.array([]) cols2 = np.array([]) values2 = np.array([], dtype=np.float64) map1 = Epetra.Map(cols, 0, comm) for i in range(cols): b = Epetra.Vector(map1) b[i] = 1.0 x = TrilinosUtils.solve_linear_problem(A, b) lines = np.nonzero(x[:])[0] col = np.repeat(i, len(lines)) vals = x[lines] lines2 = np.append(lines2, lines) cols2 = np.append(cols2, col) values2 = np.append(values2, vals) lines2 = lines2.astype(np.int32) cols2 = cols2.astype(np.int32) inds2 = np.array([lines2, cols2, values2, sz, False, False]) return inds2
def scipy_csr_matrix2CrsMatrix(sp, comm): Ap = sp.indptr Aj = sp.indices Ax = sp.data m = Ap.shape[0]-1 aMap = Epetra.Map(m, 0, comm) # range Map arMap=Epetra.Map(sp.shape[0], 0, comm) # domain Map adMap=Epetra.Map(sp.shape[1], 0, comm) aGraph = Epetra.CrsGraph( Epetra.Copy, aMap, 0) for ii in range(aMap.NumGlobalElements()): i = aMap.GID(ii) indy = range(Ap[i],Ap[i+1]) if (indy != []): aGraph.InsertGlobalIndices(i, Aj[indy]) aGraph.FillComplete(adMap, arMap) A = Epetra.CrsMatrix(Epetra.Copy, aGraph) for ii in range(aMap.NumGlobalElements()): i = aMap.GID(ii) indy = range(Ap[i],Ap[i+1]) if (indy != []): A.SumIntoGlobalValues(i, Ax[indy], Aj[indy]) A.FillComplete(adMap, arMap) return A
def _prolongation_operator_init(row_map, my_restriction_supports, my_basis_supports): """ Creates N x M matrix where N is the number of vertices in the graph and M is the number of basis functions """ range_map = row_map comm = range_map.Comm() domain_map = Epetra.Map(-1, my_basis_supports.keys(), 0, comm) P = Epetra.CrsMatrix(Epetra.Copy, range_map, 30) for basis_id in my_basis_supports: my_fine_cell_ids = my_basis_supports[basis_id] size = len(my_fine_cell_ids) assert size > 0 P.InsertGlobalValues(my_fine_cell_ids, [int(basis_id)] * size, [0.] * size) for basis_id in my_restriction_supports: my_fine_cell_ids = my_restriction_supports[basis_id] size = len(my_fine_cell_ids) assert size > 0 ierr = P.InsertGlobalValues(my_fine_cell_ids, [int(basis_id)] * size, [1.] * size) assert ierr == 0 P.FillComplete(domain_map, range_map) a = sum_of_columns(P) assert np.all(a[:] == 1.0) return P
def create_maps(graph, comm): """ Parameters ---------- graph: igraph igraph representing the network. comm: Epetra communicator Returns ------- unique_map: Epetra Map Map representing the vertices belonging to each processor nonunique_map: Epetra Map Map representing the vertices belonging to each processor as well one ghost vertex neighborhood subgraph_ids_vec: Epetra Vector Epetra vector recording the subgraph id of each vertex """ my_id = comm.MyPID() my_local_elements = graph.vs(proc_id_eq=my_id).indices my_global_elements = graph.vs[my_local_elements]['global_id'] my_ghost_elements = set().union(*graph.neighborhood(my_local_elements)) my_ghost_elements = set(graph.vs(my_ghost_elements)['global_id']) - set(my_global_elements) my_ghost_elements = sorted(list(my_ghost_elements)) assert not set(my_global_elements).intersection(my_ghost_elements) unique_map = Epetra.Map(-1, my_global_elements, 0, comm) nonunique_map = Epetra.Map(-1, my_global_elements + my_ghost_elements, 0, comm) subgraph_ids_vec = Epetra.Vector(unique_map) subgraph_ids_vec[:] = np.asarray(graph.vs[my_local_elements]['subgraph_id'], dtype=np.int32) return unique_map, nonunique_map, subgraph_ids_vec
def _create_structure_matrix(row_map, my_supports, val=1.0): """ Creates N x M matrix where N is the number of vertices in the graph and M is the number of basis functions. This matrix encodes which basis function supports (which is identified by their column ids) a given vertex (which is identified by row id) belongs to. Note: one vertex may belong to multiple supports. """ range_map = row_map comm = range_map.Comm() domain_map = Epetra.Map(-1, my_supports.keys(), 0, comm) A = Epetra.CrsMatrix(Epetra.Copy, range_map, 30) for basis_id in my_supports: my_fine_cell_ids = my_supports[basis_id] size = len(my_fine_cell_ids) assert size > 0 ierr = A.InsertGlobalValues(my_fine_cell_ids, [int(basis_id)] * size, [val] * size) assert ierr == 0 A.FillComplete(domain_map, range_map) a = sum_of_columns(A) assert np.all(a[:] >= 1.0) return A
def colMap(self): comm = Epetra.SerialComm() # Matrix building gets done on all processors # Epetra.Map(numGlobalElements, numMyElements, indexBase, comm) # If NumGlobalElements = NumMyElements (and not equal to zero) the map is # defined to be a local replicated map return Epetra.Map(self.cols, self.cols, 0, comm)
def _solve_(self, L, x, b): for iteration in range(self.iterations): # errorVector = L*x - b errorVector = Epetra.Vector(L.RangeMap()) L.Multiply(False, x, errorVector) # If A is an Epetra.Vector with map M # and B is an Epetra.Vector with map M # and C = A - B # then C is an Epetra.Vector with *no map* !!!?!?! errorVector -= b tol = errorVector.Norm1() if iteration == 0: tol0 = tol if (tol / tol0) <= self.tolerance: break xError = Epetra.Vector(L.RowMap()) Problem = Epetra.LinearProblem(L, xError, errorVector) Solver = self.Factory.Create("Klu", Problem) Solver.Solve() x[:] = x - xError if 'FIPY_VERBOSE_SOLVER' in os.environ: from fipy.tools.debug import PRINT PRINT('iterations: %d / %d' % (iteration + 1, self.iterations)) PRINT('residual:', errorVector.Norm2())
def __init__(self): self.matrices = { 'A': Epetra.CrsMatrix(Epetra.Copy, std_map, 5), 'b': Epetra.Vector(std_map) } self.std_map = {1: std_map}
def solve_linear_problem(comm, A, b): """ retorna a solucao do sistema linear Ax = b input: A: matriz do sistema b: termo fonte output: x:solucao """ n = len(b) assert A.NumMyCols() == A.NumMyRows() assert A.NumMyCols() == n if A.Filled(): pass else: A.FillComplete() std_map = Epetra.Map(n, 0, comm) x = Epetra.Vector(std_map) linearProblem = Epetra.LinearProblem(A, x, b) solver = AztecOO.AztecOO(linearProblem) solver.SetAztecOption(AztecOO.AZ_output, AztecOO.AZ_warnings) solver.Iterate(10000, 1e-14) return x
def matrix_scipy_to_epetra(A_scipy, A_epetra=None): """ Converts scipy matrix to a local (non-distributed) epetra matrix. Parameters ---------- A_scipy: Scipy Matrix A_epetra: Epetra Matrix, optional An existing epetra matrix which has the same structure as the scipy matrix Returns ------- A_epetra: Epetra Matrix If an existing Epetra matrix is passed, the values are replaced """ comm = Epetra.MpiComm(MPI.COMM_SELF) map = Epetra.Map(A_scipy.shape[0], 0, comm) B = A_scipy.tocoo() if A_epetra is None: A_epetra = Epetra.CrsMatrix(Epetra.Copy, map, A_scipy.getnnz(axis=1).astype(np.int32), True) A_epetra.InsertGlobalValues(B.row, B.col, B.data) ierr = A_epetra.FillComplete() else: ierr = A_epetra.ReplaceMyValues(B.row, B.col, B.data) assert ierr == 0 return A_epetra
def setup(self): comm = Epetra.PyComm() std_map = Epetra.Map(10, 0, comm) class DummyMatrixManager: def __init__(self): self.matrices = { 'A': Epetra.CrsMatrix(Epetra.Copy, std_map, 5), 'b': Epetra.Vector(std_map) } self.std_map = {1: std_map} def get_matrix(self, name): return self.matrices[name] get_vector = get_matrix class DummyMesh: def __init__(self): self.matrix_manager = DummyMatrixManager() mesh = DummyMesh() self.problem = LinearProblem(mesh, None, 1)
def __init__(self, operator, pid=0, label=""): Epetra.Operator.__init__(self) from tools import RealOperator self.__comm = Epetra.PyComm() self.__label = label self.__pid = pid if self.__comm.MyPID() == pid: if operator.dtype == 'complex128' or operator.dtype == 'complex64': self.__operator = RealOperator(operator) else: self.__operator = operator else: self.__operator = None if self.__comm.MyPID() == pid: num_my_elems_domain = self.__operator.shape[1] num_my_elems_range = self.__operator.shape[0] else: num_my_elems_domain = 0 num_my_elems_range = 0 self.__rangeMap = Epetra.Map(-1, num_my_elems_range, 0, self.__comm) self.__domainMap = Epetra.Map(-1, num_my_elems_domain, 0, self.__comm)
def test_Complex_Epetra(): try: from PyTrilinos import Epetra from jadapy import ComplexEpetraInterface except ImportError: pytest.skip("Trilinos not found") dtype = numpy.float64 numpy.random.seed(1234) tol = numpy.finfo(dtype).eps * 1e3 atol = tol * 10 n = 20 k = 5 comm = Epetra.PyComm() map = Epetra.Map(n, 0, comm) a1, a2 = generate_Complex_Epetra_test_matrix(map, [n, n], dtype) b1, b2 = generate_Complex_Epetra_test_matrix(map, [n, n], dtype) interface = ComplexEpetraInterface.ComplexEpetraInterface(map) alpha, beta = jdqz.jdqz(a2, b2, k, tol=tol, interface=interface) jdqz_eigs = numpy.array(sorted(alpha / beta, key=lambda x: abs(x))) eigs = scipy.linalg.eigvals(a1, b1) eigs = numpy.array(sorted(eigs, key=lambda x: abs(x))) eigs = eigs[:k] assert_allclose(jdqz_eigs.real, eigs.real, rtol=0, atol=atol) assert_allclose(abs(jdqz_eigs.imag), abs(eigs.imag), rtol=0, atol=atol)
def _globalMatrixAndVectors(self): if not hasattr(self, 'globalVectors'): globalMatrix = self.matrix.asTrilinosMeshMatrix() mesh = self.var.mesh localNonOverlappingCellIDs = mesh._localNonOverlappingCellIDs ## The following conditional is required because empty indexing is not altogether functional. ## This numpy.empty((0,))[[]] and this numpy.empty((0,))[...,[]] both work, but this ## numpy.empty((3, 0))[...,[]] is broken. if self.var.shape[-1] != 0: s = (Ellipsis, localNonOverlappingCellIDs) else: s = (localNonOverlappingCellIDs,) nonOverlappingVector = Epetra.Vector(globalMatrix.domainMap, self.var[s].ravel()) from fipy.variables.coupledCellVariable import _CoupledCellVariable if isinstance(self.RHSvector, _CoupledCellVariable): RHSvector = self.RHSvector[localNonOverlappingCellIDs] else: RHSvector = numerix.reshape(numerix.array(self.RHSvector), self.var.shape)[s].ravel() nonOverlappingRHSvector = Epetra.Vector(globalMatrix.rangeMap, RHSvector) del RHSvector overlappingVector = Epetra.Vector(globalMatrix.colMap, self.var) self.globalVectors = (globalMatrix, nonOverlappingVector, nonOverlappingRHSvector, overlappingVector) return self.globalVectors
def __solve_one_step(self, rhs, RAP, R): # returns P*(RAP)^-1* R*rhs rhs_coarse = Epetra.Vector(R.DomainMap()) R.Multiply(True, rhs, rhs_coarse) if not np.max(np.abs(sum_of_columns(RAP))) < RAP.NormInf() * 1e-10: warnings.warn("sum of matrix columns does not equal to zero") # Set dirichlet boundary condition at a point if np.max(np.abs(sum_of_columns(RAP))) < RAP.NormInf() * 1e-10: row = 0 RAP = Epetra.CrsMatrix(RAP) RAP = epetra_set_matrow_to_zero(RAP, row=0) rhs_coarse = epetra_set_vecrow_to_zero(rhs_coarse, row=0) if row in RAP.Map().MyGlobalElements(): ierr = RAP.ReplaceGlobalValues([row], [row], 1.0) assert ierr == 0 sol_coarse = solve_direct(RAP, rhs_coarse) sol_fine = Epetra.Vector(self.P.RangeMap()) self.P.Multiply(False, sol_coarse, sol_fine) return sol_fine
def test_Epetra_lowdim(): try: from PyTrilinos import Epetra from jadapy import EpetraInterface except ImportError: pytest.skip("Trilinos not found") dtype = numpy.float64 numpy.random.seed(1234) tol = numpy.finfo(dtype).eps * 1e3 atol = tol * 10 n = 20 k = 2 comm = Epetra.PyComm() map = Epetra.Map(n, 0, comm) a1, a2 = generate_Epetra_test_matrix(map, [n, n], dtype) interface = EpetraInterface.EpetraInterface(map) alpha = jdqr.jdqr(a2, k, Target.LargestMagnitude, tol=tol, subspace_dimensions=[10, 18], interface=interface) jdqr_eigs = numpy.array(sorted(alpha, key=lambda x: -abs(x))) eigs = scipy.linalg.eigvals(a1) eigs = numpy.array(sorted(eigs, key=lambda x: -abs(x))) eigs = eigs[:k] assert_allclose(jdqr_eigs.real, eigs.real, rtol=0, atol=atol) assert_allclose(abs(jdqr_eigs.imag), abs(eigs.imag), rtol=0, atol=atol)
def iterative_solver(List, Matrix, InputLHS, RHS, Prec): LHS = Epetra.MultiVector(InputLHS) Time = Epetra.Time(Matrix.Comm()) hasConditionNumber = False; Solver = AztecOO.AztecOO(Matrix, LHS, RHS) Solver.SetPrecOperator(Prec) if (List['az_solver'] == "AZ_gmres"): Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres); elif List['az_solver'] == "AZ_cg": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg); elif List['az_solver'] == "AZ_cg_condnum": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cg_condnum); hasConditionNumber = True elif List['az_solver'] == "AZ_gmres_condnum": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_gmres_condnum); hasConditionNumber = True elif List['az_solver'] == "AZ_bicgstab": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_bicgstab); elif List['az_solver'] == "AZ_tfqmr": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_tfqmr); elif List['az_solver'] == "AZ_cgs": Solver.SetAztecOption(AztecOO.AZ_solver, AztecOO.AZ_cgs); else: print "Solver type not correct, ", List['az_solver'] Solver.SetAztecOption(AztecOO.AZ_output, 16); if List['iters'] < 0 | List['iters'] > MAX_ITERATIONS: print "Maximum number of iterations either negative of > ", MAX_ITERATIONS; raise("PARAMETER_ERROR"); if List['tol'] < 1e-12: print "Tolerance is too small" raise("PARAMETER_ERROR"); if List['az_kspace'] > 0 & List['az_kspace'] <= MAX_KSPACE: Solver.SetAztecOption(AztecOO.AZ_kspace, List['az_kspace']); else: print "Krylov space dimension either negative of >", MAX_KSPACE print "You have", List['az_kspace'] raise("PARAMETER_ERROR"); if List['az_output'] == "16": Solver.SetAztecOption(AztecOO.AZ_output, 16) elif List['az_output'] == "32": Solver.SetAztecOption(AztecOO.AZ_output, 32) elif List['az_output'] == "AZ_last": Solver.SetAztecOption(AztecOO.AZ_output, AztecOO.AZ_last) elif List['az_output'] == "AZ_none": Solver.SetAztecOption(AztecOO.AZ_output, AztecOO.AZ_none) err = Solver.Iterate(List['iters'], List['tol']) if hasConditionNumber: ConditionNumber = Solver.GetStatus(AztecOO.AZ_condnum) else: ConditionNumber = 0.0; return (err, Solver.NumIters(), Time.ElapsedTime(), ConditionNumber)
def __init__(self, comm, number_of_elements=10): self.comm = comm self.rank = comm.MyPID() self.size = comm.NumProc() if self.rank == 0: number_of_rows = number_of_elements else: number_of_rows = 0 unbalanced_map = Epetra.Map(-1, number_of_rows, 0, self.comm) self.A = Epetra.CrsMatrix(Epetra.Copy, unbalanced_map, 3) self.x = Epetra.Vector(unbalanced_map) self.b = Epetra.Vector(unbalanced_map) for gid in unbalanced_map.MyGlobalElements(): if gid == 0: self.A.InsertGlobalValues(gid, [1], [gid]) self.b[0] = -1 elif gid == (number_of_elements - 1): self.A.InsertGlobalValues(gid, [1], [gid]) self.b[-1] = 1 else: self.A.InsertGlobalValues(gid, [-1, 2, -1], [gid - 1, gid, gid + 1]) #optimizes storage self.A.FillComplete()
def get_inverse_tril(self, A, rows): """ Obter a matriz inversa de A obs: A deve ser quadrada input: A: CrsMatrix rows: numero de linhas output: INV: CrsMatrix inversa de A """ num_cols = A.NumMyCols() num_rows = A.NumMyRows() assert num_cols == num_rows map1 = Epetra.Map(rows, 0, self.comm) Inv = Epetra.CrsMatrix(Epetra.Copy, map1, 3) for i in range(rows): b = Epetra.Vector(map1) b[i] = 1.0 x = self.solve_linear_problem(A, b, rows) lines = np.nonzero(x[:])[0].astype(np.int32) col = np.repeat(i, len(lines)).astype(np.int32) Inv.InsertGlobalValues(lines, col, x[lines]) return Inv
def __init__(self, size, bandwidth=0, sizeHint=None, nonOverlappingMap=None, overlappingMap=None): """Creates a `_TrilinosMatrix`. :Parameters: - `size`: The size N for an N by N matrix. - `bandwidth`: The proposed band width of the matrix. - `sizeHint`: ??? - `map`: The Epetra `Map` for the rows that this processor holds """ if sizeHint is not None and bandwidth == 0: bandwidth = (sizeHint + size - 1) / (size or 1) else: bandwidth = bandwidth if nonOverlappingMap is None: comm = Epetra.PyComm() # Matrix building gets done on one processor - it gets the map for # all the rows if comm.MyPID() == 0: nonOverlappingMap = Epetra.Map(size, range(0, size), 0, comm) else: nonOverlappingMap = Epetra.Map(size, [], 0, comm) matrix = Epetra.CrsMatrix(Epetra.Copy, nonOverlappingMap, bandwidth*3/2) # Leave extra bandwidth, to handle multiple insertions into the # same spot. It's memory-inefficient, but it'll get cleaned up when # FillComplete is called, and according to the Trilinos devs the # performance boost will be worth it. _TrilinosMatrixBase.__init__(self, matrix=matrix, nonOverlappingMap=nonOverlappingMap, overlappingMap=overlappingMap, bandwidth=bandwidth)
def __matmul__(self, x): if isinstance(x, numpy.ndarray): local_map = Epetra.LocalMap(x.shape[0], 0, self.Comm()) x = Epetra.MultiVector(local_map, x.T) tmp = Vector(self.Map(), x.NumVectors()) tmp.Multiply('N', 'N', 1.0, self, x, 0.0) return tmp
def __rmul__(self, other): if type(numerix.ones(1)) == type(other): y = Epetra.Vector(other) result = Epetra.Vector(self.nonOverlappingMap) self._getMatrix().Multiply(True, y, result) return _trilinosToNumpyVector(result) else: return self * other
def __init__(self, layers): self.__comm = Epetra.PyComm() self.__layers = layers self.__single_proc_map, self.__multiple_proc_map = self.generate_maps() self.__importer = Epetra.Import(self.__multiple_proc_map, self.__single_proc_map) self.__exporter = Epetra.Export(self.__multiple_proc_map, self.__single_proc_map)
def get_negative_matrix(self, matrix, n): std_map = Epetra.Map(n, 0, self.comm) if matrix.Filled() == False: matrix.FillComplete() A = Epetra.CrsMatrix(Epetra.Copy, std_map, 3) EpetraExt.Add(matrix, False, -1.0, A, 1.0) return A
def dot(self, x): local_map = Epetra.LocalMap(self.shape[1], 0, self.Comm()) tmp = Epetra.MultiVector(local_map, x.shape[1]) tmp.Multiply('T', 'N', 1.0, self, x, 0.0) if self.shape[1] == 1 or x.shape[1] == 1: # Numpy expects a 1D array in this case return tmp.array.copy().flatten() return tmp.array.copy().T
def takeDiagonal(self): nonoverlapping_result = _TrilinosMatrixFromShape.takeDiagonal(self) overlapping_result = Epetra.Vector(self.colMap) overlapping_result.Import(nonoverlapping_result, Epetra.Import(self.colMap, self.domainMap), Epetra.Insert) return overlapping_result
def __init__(self, mesh, interpolation_method=None, x=None): self.comm = Epetra.PyComm() std_map = Epetra.Map(len(mesh.all_volumes), 0, self.comm) self.T = Epetra.CrsMatrix(Epetra.Copy, std_map, 0) self.Q = Epetra.Vector(std_map) if x is None: self.x = Epetra.Vector(std_map) else: self.x = x
def __init_field_graph(self): # Assign velocity_x (ux) and velocity_y (uy) indices for each node ##Rambod change removed *2 ( added it back) self.number_of_field_variables = 2 * self.__global_number_of_nodes global_indices = self.balanced_map.MyGlobalElements() Global_Indices = global_indices #self.balanced_map.MyGlobalElements() XY_Global_Indices = np.zeros(2 * len(Global_Indices), dtype=np.int32) for index in range(len(Global_Indices)): XY_Global_Indices[2 * index] = 2 * Global_Indices[index] XY_Global_Indices[2 * index + 1] = 2 * Global_Indices[index] + 1 XY_list = XY_Global_Indices.tolist() field_global_indices = np.empty(2 * global_indices.shape[0], dtype=np.int32) field_global_indices[0:-1:2] = 2 * global_indices field_global_indices[1::2] = 2 * global_indices + 1 ### removed multiply by two here rambod Rambod Number_of_Global_Variables = 2 * self.__global_number_of_nodes # create Epetra Map based on node degrees of Freedom #self.field_balanced_map = Epetra.Map(self.number_of_field_variables,field_global_indices.tolist(),0, self.comm) self.field_balanced_map = Epetra.Map(Number_of_Global_Variables, XY_list, 0, self.comm) # Instantiate the corresponding graph self.balanced_field_graph = Epetra.CrsGraph(Epetra.Copy, self.field_balanced_map, True) # fill the field graph for i in global_indices: # array of global indices in neighborhood of each node global_index_array = ( self.balanced_neighborhood_graph.ExtractGlobalRowCopy(i)) # convert global node indices to appropriate field indices field_index_array = (np.sort( np.r_[2 * global_index_array, 2 * global_index_array + 1]).astype(np.int32)) # insert rows into balanced graph per appropriate rows self.balanced_field_graph.InsertGlobalIndices( 2 * i, field_index_array) self.balanced_field_graph.InsertGlobalIndices( 2 * i + 1, field_index_array) # complete fill of balanced graph self.balanced_field_graph.FillComplete() # create balanced field map from balanced field neighborhood graph self.balanced_field_map = self.balanced_field_graph.Map() return