How to achieve the transformation of the right-hand vector b under different processes

General
1

Dear all,
I am trying to convert vector b in different processes.Specifically, how to convert b assembled under 10 processes and b assembled under 4 processes into each other?(this is just an example).
How to obtain the corresponding mapping?I couldn’t find it in dolfinx.

# 
from mpi4py import MPI
from petsc4py import PETSc
from dolfinx import mesh, fem, io
import petsc4py
from mpi4py import MPI
from petsc4py import PETSc
import numpy as np
import dolfinx
from dolfinx import default_real_type, fem, io, mesh,default_scalar_type
from dolfinx.fem.petsc import assemble_matrix, assemble_vector
from ufl import (CellDiameter, FacetNormal, TestFunction, TrialFunction, avg,
                 conditional, div, dot, dS, ds, dx, grad, gt, inner, outer,
                 TrialFunctions,TestFunctions,curl,cross)
import ufl
from dolfinx.io import gmshio,XDMFFile
from basix.ufl import element,mixed_element 
from dolfinx.fem.petsc import (apply_lifting, assemble_matrix, assemble_vector, 
                                 create_vector, set_bc,create_matrix)
import time
from dolfinx.fem.petsc import (apply_lifting, assemble_matrix_block, assemble_vector_block, 
                                 create_vector_block, set_bc,create_matrix_block,create_matrix)
import os 

msh = mesh.create_rectangle(
    comm=MPI.COMM_WORLD,
    points=((0.0, 0.0), (1.0, 1.0)),
    n=(4, 4),
    cell_type=mesh.CellType.triangle,
)
P_space=fem.functionspace(msh,("CG",1))  
 
P,q=ufl.TrialFunction(P_space), ufl.TestFunction(P_space)  

h = CellDiameter(msh) 
a = fem.form(inner(grad(P), grad(q)) * dx+0.1/h*inner(P,q)*ds ) 
L = fem.form(inner(fem.Constant(msh, 1.0), q) * dx)
A = fem.petsc.assemble_matrix(a); A.assemble() 
b = fem.petsc.assemble_vector(L) 
b.setRandom() 

################define in sub process
comm = MPI.COMM_WORLD  
rank = comm.Get_rank() 

color = 0 if rank < 2 else MPI.UNDEFINED
poisson_comm = comm.Split(color=color, key=rank)

if poisson_comm:  
    prank = poisson_comm.Get_rank() 
    poss_msh = mesh.create_rectangle(
    comm=poisson_comm,
    points=((0.0, 0.0), (1.0, 1.0)),
    n=(4, 4),
    cell_type=mesh.CellType.triangle,
    )
    gdim = poss_msh.geometry.dim   

    ph = CellDiameter(poss_msh) 
    pV = fem.functionspace(poss_msh, ("CG", 1))   
    
    pu, pv = TrialFunction(pV), TestFunction(pV) 

    pa = fem.form(inner(grad(pu), grad(pv)) * dx+0.1/ph*inner(pu,pv)*ds ) 

    pL = fem.form(inner(fem.Constant(poss_msh, 1.0), pv) * dx)

    pA = fem.petsc.assemble_matrix(pa); pA.assemble() 
    
    pb = fem.petsc.assemble_vector(pL) 

    #pb=b(dofmap)


else:

    pass
2

You should then store the vector in a dolfinx.fem.Function of the corresponding space, and use adios4dolfinx to checkpoint it: ADIOS4DOLFINx - A framework for checkpointing in DOLFINx — ADIOS2Wrappers

1 Like
3

Thanks dokken,
I have been using dolfinx0.8.Thus I want to solve it through indexing.

For example, regarding this issue：

# 
from mpi4py import MPI
from petsc4py import PETSc
from dolfinx import mesh, fem, io
import petsc4py
from mpi4py import MPI
from petsc4py import PETSc
import numpy as np
import dolfinx
from dolfinx import default_real_type, fem, io, mesh,default_scalar_type
from dolfinx.fem.petsc import assemble_matrix, assemble_vector
from ufl import (CellDiameter, FacetNormal, TestFunction, TrialFunction, avg,
                 conditional, div, dot, dS, ds, dx, grad, gt, inner, outer,
                 TrialFunctions,TestFunctions,curl,cross)
import ufl
from dolfinx.io import gmshio,XDMFFile
from basix.ufl import element,mixed_element 
from dolfinx.fem.petsc import (apply_lifting, assemble_matrix, assemble_vector, 
                                 create_vector, set_bc,create_matrix)
import time
from dolfinx.fem.petsc import (apply_lifting, assemble_matrix_block, assemble_vector_block, 
                                 create_vector_block, set_bc,create_matrix_block,create_matrix)
import os 

comm = MPI.COMM_WORLD  
rank = comm.Get_rank() 

msh = mesh.create_rectangle(
    comm=MPI.COMM_WORLD,
    points=((0.0, 0.0), (1.0, 1.0)),
    n=(2, 2),
    cell_type=mesh.CellType.triangle,
)
P_space=fem.functionspace(msh,("CG",1))  
 
P,q=ufl.TrialFunction(P_space), ufl.TestFunction(P_space)  

def frv(x):
    values = np.zeros((2, x.shape[1]), dtype=PETSc.ScalarType)
    values=x[0]**2+x[1]**2
    return values

fr=fem.Function(P_space)
fr.interpolate(frv)

h = CellDiameter(msh) 
a = fem.form(inner(grad(P), grad(q)) * dx+0.1/h*inner(P,q)*ds ) 
L = fem.form(inner(fr, q) * dx)
A = fem.petsc.assemble_matrix(a); A.assemble() 
b = fem.petsc.assemble_vector(L) 

offset = P_space.dofmap.index_map.size_local * P_space.dofmap.index_map_bs 
ff=fem.Function(P_space) 
print(f'rank is {rank} val is :',b.array_r) 

dof_coordinates = P_space.tabulate_dof_coordinates()
num_local_dofs = P_space.dofmap.index_map.size_local

out = open(f'dof_cor{rank}.csv', "w")
for x in dof_coordinates[:num_local_dofs, :]:
    print(f"{x[0]:.5f},{x[1]:.5f},{x[2]:.5f}", file=out)
out.close()

In fact, only the node numbers under each process need to be known.
In this example, use 2 processe:
rank 0 :[9 8 6 3]
rank 1 :[5 7 4 1 2]
I want to obtain this index. Does dolfinx store this information?