void xyza2laba(double* pixar) {
double Lstar, astar, bstar;
if ((pixar[1] / Y_d65) > 0.008856) {
Lstar = 116.0 * std::pow((pixar[1] / Y_d65), 1.0/3.0) - 16.0;
} else {
Lstar = 903.3 * pixar[1] / Y_d65;
}
astar = 500.0 * (_f_(pixar[0] / X_d65) - _f_(pixar[1] / Y_d65));
bstar = 200.0 * (_f_(pixar[1] / Y_d65) - _f_(pixar[2] / Z_d65));
pixar[0] = Lstar;
pixar[1] = astar;
pixar[2] = bstar; // pixar[3] = unchanged alpha
}
int main(int argc, char** args){
uint64_t a; //domain(_1) = [0..infinity]
uint64_t b; //domain(_2) = [0..infinity]
uint64_t _3; //domain(_3) = [0..infinity]
uint16_t _4; //domain(_4) = [43..43]
void* _5;
int64_t _7; //domain(_7) = [empty..empty]
uint64_t _8; //domain(_8) = [0..infinity]
uint32_t _9; //domain(_9) = [65536..65536]
void* _10;
int64_t _12; //domain(_12) = [empty..empty]
//const %4 = 43 : int
_4 = 43;
//invoke (%3) = (%4) whileloop:f : function(int)->(int)
{
_3 = _f_(_4);
}
//assign %1 = %3 : int
a = _3;
//fieldload %5 = %0 out : {int[][] args,{method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s} out}
//fieldload %6 = %5 println : {method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s}
//indirectinvoke () = %6 (%1) : method(any)->()
{
printf("%"PRIu64"\n", a);
}
//const %9 = 65536 : int
_9 = 65536;
//invoke (%8) = (%9) whileloop:f : function(int)->(int)
{
_8 = _f_(_9);
}
//assign %2 = %8 : int
b = _8;
//fieldload %10 = %0 out : {int[][] args,{method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s} out}
//fieldload %11 = %10 println : {method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s}
//indirectinvoke () = %11 (%2) : method(any)->()
{
printf("%"PRIu64"\n", b);
}
//return
exit(0);
}
int main(int argc, char** args){
_DECL_1DARRAY_BYTE(data);
_DECL_1DARRAY_BYTE(arr);
BYTE _3;
BYTE _4;
BYTE _5;
_DECL_1DARRAY_BYTE(_6);
_DECL_1DARRAY_BYTE(_7);
BYTE _8;
BYTE _9;
BYTE _10;
BYTE _11;
BYTE _12;
BYTE _13;
_DECL_1DARRAY_BYTE(_14);
void* _15;
int64_t _17;
//const %3 = 01100001b : byte
_3 = 0b01100001;
//const %4 = 01100010b : byte
_4 = 0b01100010;
//const %5 = 01100011b : byte
_5 = 0b01100011;
//newlist %6 = (%3, %4, %5) : byte[]
_NEW_1DARRAY_BYTE(_6, 3, 0b0);
_6[0] = _3; _6[1] = _4; _6[2] = _5;
//assign %1 = %6 : byte[]
_COPY_1DARRAY_BYTE(data, _6);
//invoke (%7) = (%1) appendarray:f : function(byte[])->(byte[])
{
void* tmp_data;
_COPY_1DARRAY_PARAM(data, tmp_data, BYTE);
_7 = _f_(tmp_data, data_size, _1DARRAYSIZE_PARAM_CALLBYREFERENCE(_7));
}
//assign %2 = %7 : byte[]
_COPY_1DARRAY_BYTE(arr, _7);
//fieldload %15 = %0 out : {int[][] args,{method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s} out}
//fieldload %16 = %15 print : {method(any)->() print,method(int[])->() print_s,method(any)->() println,method(int[])->() println_s}
//lengthof %17 = %2 : byte[]
_17 = arr_size;
//indirectinvoke () = %16 (%17) : method(any)->()
{
printf("%"PRId64, _17);
}
//return
exit(0);
}
int main(int argc, char * argv[])
{
typedef MPI::HGeometryForest<DIM,DOW> forest_t;
typedef MPI::BirdView<forest_t> ir_mesh_t;
typedef FEMSpace<double,DIM,DOW> fe_space_t;
typedef MPI::DOF::GlobalIndex<forest_t, fe_space_t> global_index_t;
MPI_Init(&argc, &argv);
forest_t forest(MPI_COMM_WORLD);
ir_mesh_t ir_mesh;
MPI::load_mesh(argv[1], forest, ir_mesh); /// 从一个目录中读入网格数据
int round = 0;
if (argc >= 3) round = atoi(argv[2]);
ir_mesh.globalRefine(round);
ir_mesh.semiregularize();
ir_mesh.regularize(false);
TemplateGeometry<DIM> tri;
tri.readData("triangle.tmp_geo");
CoordTransform<DIM,DIM> tri_ct;
tri_ct.readData("triangle.crd_trs");
TemplateDOF<DIM> tri_td(tri);
tri_td.readData("triangle.1.tmp_dof");
BasisFunctionAdmin<double,DIM,DIM> tri_bf(tri_td);
tri_bf.readData("triangle.1.bas_fun");
std::vector<TemplateElement<double,DIM,DIM> > tmp_ele(1);
tmp_ele[0].reinit(tri, tri_td, tri_ct, tri_bf);
RegularMesh<DIM,DOW>& mesh = ir_mesh.regularMesh();
fe_space_t fem_space(mesh, tmp_ele);
u_int n_ele = mesh.n_geometry(DIM);
fem_space.element().resize(n_ele);
for (int i = 0;i < n_ele;i ++) {
fem_space.element(i).reinit(fem_space, i, 0);
}
fem_space.buildElement();
fem_space.buildDof();
fem_space.buildDofBoundaryMark();
std::cout << "Building global indices ... " << std::flush;
global_index_t global_index(forest, fem_space);
global_index.build();
std::cout << "OK!" << std::endl;
Epetra_MpiComm comm(forest.communicator());
Epetra_Map map(global_index.n_global_dof(), global_index.n_primary_dof(), 0, comm);
global_index.build_epetra_map(map);
/// 构造 Epetra 的分布式稀疏矩阵模板
std::cout << "Build sparsity pattern ... " << std::flush;
Epetra_FECrsGraph G(Copy, map, 10);
fe_space_t::ElementIterator
the_ele = fem_space.beginElement(),
end_ele = fem_space.endElement();
for (;the_ele != end_ele;++ the_ele) {
const std::vector<int>& ele_dof = the_ele->dof();
u_int n_ele_dof = ele_dof.size();
/**
* 建立从局部自由度数组到全局自由度数组的映射表，这是实现分布式并行
* 状态下的数据结构的关键一步。
*/
std::vector<int> indices(n_ele_dof);
for (u_int i = 0;i < n_ele_dof;++ i) {
indices[i] = global_index(ele_dof[i]);
}
G.InsertGlobalIndices(n_ele_dof, &indices[0], n_ele_dof, &indices[0]);
}
G.GlobalAssemble();
std::cout << "OK!" << std::endl;
/// 准备构造 Epetra 的分布式稀疏矩阵和计算分布式右端项
std::cout << "Build sparse matrix ... " << std::flush;
Epetra_FECrsMatrix A(Copy, G);
Epetra_FEVector b(map);
the_ele = fem_space.beginElement();
for (;the_ele != end_ele;++ the_ele) {
double vol = the_ele->templateElement().volume();
const QuadratureInfo<DIM>& qi = the_ele->findQuadratureInfo(5);
std::vector<Point<DIM> > q_pnt = the_ele->local_to_global(qi.quadraturePoint());
int n_q_pnt = qi.n_quadraturePoint();
std::vector<double> jac = the_ele->local_to_global_jacobian(qi.quadraturePoint());
std::vector<std::vector<double> > bas_val = the_ele->basis_function_value(q_pnt);
std::vector<std::vector<std::vector<double> > > bas_grad = the_ele->basis_function_gradient(q_pnt);
const std::vector<int>& ele_dof = the_ele->dof();
u_int n_ele_dof = ele_dof.size();
FullMatrix<double> ele_mat(n_ele_dof, n_ele_dof);
Vector<double> ele_rhs(n_ele_dof);
for (u_int l = 0;l < n_q_pnt;++ l) {
double JxW = vol*jac[l]*qi.weight(l);
double f_val = _f_(q_pnt[l]);
for (u_int i = 0;i < n_ele_dof;++ i) {
for (u_int j = 0;j < n_ele_dof;++ j) {
ele_mat(i, j) += JxW*(bas_val[i][l]*bas_val[j][l] +
innerProduct(bas_grad[i][l], bas_grad[j][l]));
}
ele_rhs(i) += JxW*f_val*bas_val[i][l];
}
}
/**
* 此处将单元矩阵和单元载荷先计算好，然后向全局的矩阵和载荷向量上
* 集中，可以提高效率。
*/
std::vector<int> indices(n_ele_dof);
for (u_int i = 0;i < n_ele_dof;++ i) {
indices[i] = global_index(ele_dof[i]);
}
A.SumIntoGlobalValues(n_ele_dof, &indices[0], n_ele_dof, &indices[0], &ele_mat(0,0));
b.SumIntoGlobalValues(n_ele_dof, &indices[0], &ele_rhs(0));
}
A.GlobalAssemble();
b.GlobalAssemble();
std::cout << "OK!" << std::endl;
/// 准备解向量。
Epetra_Vector x(map);
/// 调用 AztecOO 的求解器。
std::cout << "Solving the linear system ..." << std::flush;
Epetra_LinearProblem problem(&A, &x, &b);
AztecOO solver(problem);
ML_Epetra::MultiLevelPreconditioner precond(A, true);
solver.SetPrecOperator(&precond);
solver.SetAztecOption(AZ_solver, AZ_cg);
solver.SetAztecOption(AZ_output, 100);
solver.Iterate(5000, 1.0e-12);
std::cout << "OK!" << std::endl;
Epetra_Map fe_map(-1, global_index.n_local_dof(), &global_index(0), 0, comm);
FEMFunction<double,DIM> u_h(fem_space);
Epetra_Import importer(fe_map, map);
Epetra_Vector X(View, fe_map, &u_h(0));
X.Import(x, importer, Add);
char filename[1024];
sprintf(filename, "u_h%d.dx", forest.rank());
u_h.writeOpenDXData(filename);
MPI_Finalize();
return 0;
}
int main(int argc, char * argv[])
{
typedef MPI::HGeometryForest<DIM,DOW> forest_t;
typedef MPI::BirdView<forest_t> ir_mesh_t;
typedef FEMSpace<double,DIM,DOW> fe_space_t;
typedef MPI::DOF::GlobalIndex<forest_t, fe_space_t> global_index_t;
MPI_Init(&argc, &argv);
forest_t forest(MPI_COMM_WORLD);
ir_mesh_t ir_mesh;
MPI::load_mesh(argv[1], forest, ir_mesh); /// 从一个目录中读入网格数据
int round = 0;
if (argc >= 3) round = atoi(argv[2]);
ir_mesh.globalRefine(round);
ir_mesh.semiregularize();
ir_mesh.regularize(false);
TemplateGeometry<DIM> tri;
tri.readData("triangle.tmp_geo");
CoordTransform<DIM,DIM> tri_ct;
tri_ct.readData("triangle.crd_trs");
TemplateDOF<DIM> tri_td(tri);
tri_td.readData("triangle.1.tmp_dof");
BasisFunctionAdmin<double,DIM,DIM> tri_bf(tri_td);
tri_bf.readData("triangle.1.bas_fun");
std::vector<TemplateElement<double,DIM,DIM> > tmp_ele(1);
tmp_ele[0].reinit(tri, tri_td, tri_ct, tri_bf);
RegularMesh<DIM,DOW>& mesh = ir_mesh.regularMesh();
fe_space_t fem_space(mesh, tmp_ele);
u_int n_ele = mesh.n_geometry(DIM);
fem_space.element().resize(n_ele);
for (int i = 0;i < n_ele;i ++) {
fem_space.element(i).reinit(fem_space, i, 0);
}
fem_space.buildElement();
fem_space.buildDof();
fem_space.buildDofBoundaryMark();
std::cout << "Building global indices ... " << std::flush;
global_index_t global_index(forest, fem_space);
global_index.build();
std::cout << "OK!" << std::endl;
Epetra_MpiComm comm(forest.communicator());
Epetra_Map map(global_index.n_global_dof(), global_index.n_primary_dof(), 0, comm);
global_index.build_epetra_map(map);
/// 构造 Epetra 的分布式稀疏矩阵模板
std::cout << "Build sparsity pattern ... " << std::flush;
Epetra_FECrsGraph G(Copy, map, 10);
fe_space_t::ElementIterator
the_ele = fem_space.beginElement(),
end_ele = fem_space.endElement();
for (;the_ele != end_ele;++ the_ele) {
const std::vector<int>& ele_dof = the_ele->dof();
u_int n_ele_dof = ele_dof.size();
/**
* 建立从局部自由度数组到全局自由度数组的映射表，这是实现分布式并行
* 状态下的数据结构的关键一步。
*/
std::vector<int> indices(n_ele_dof);
for (u_int i = 0;i < n_ele_dof;++ i) {
indices[i] = global_index(ele_dof[i]);
}
G.InsertGlobalIndices(n_ele_dof, &indices[0], n_ele_dof, &indices[0]);
}
G.GlobalAssemble();
std::cout << "OK!" << std::endl;
/// 准备构造 Epetra 的分布式稀疏矩阵和计算分布式右端项
std::cout << "Build sparse matrix ... " << std::flush;
Epetra_FECrsMatrix A(Copy, G);
Epetra_FEVector b(map);
the_ele = fem_space.beginElement();
for (;the_ele != end_ele;++ the_ele) {
double vol = the_ele->templateElement().volume();
const QuadratureInfo<DIM>& qi = the_ele->findQuadratureInfo(5);
std::vector<Point<DIM> > q_pnt = the_ele->local_to_global(qi.quadraturePoint());
int n_q_pnt = qi.n_quadraturePoint();
std::vector<double> jac = the_ele->local_to_global_jacobian(qi.quadraturePoint());
std::vector<std::vector<double> > bas_val = the_ele->basis_function_value(q_pnt);
std::vector<std::vector<std::vector<double> > > bas_grad = the_ele->basis_function_gradient(q_pnt);
const std::vector<int>& ele_dof = the_ele->dof();
u_int n_ele_dof = ele_dof.size();
FullMatrix<double> ele_mat(n_ele_dof, n_ele_dof);
Vector<double> ele_rhs(n_ele_dof);
for (u_int l = 0;l < n_q_pnt;++ l) {
double JxW = vol*jac[l]*qi.weight(l);
double f_val = _f_(q_pnt[l]);
for (u_int i = 0;i < n_ele_dof;++ i) {
for (u_int j = 0;j < n_ele_dof;++ j) {
ele_mat(i, j) += JxW*(innerProduct(bas_grad[i][l], bas_grad[j][l]));
}
ele_rhs(i) += JxW*f_val*bas_val[i][l];
}
}
/**
* 此处将单元矩阵和单元载荷先计算好，然后向全局的矩阵和载荷向量上
* 集中，可以提高效率。
*/
std::vector<int> indices(n_ele_dof);
for (u_int i = 0;i < n_ele_dof;++ i) {
indices[i] = global_index(ele_dof[i]);
}
A.SumIntoGlobalValues(n_ele_dof, &indices[0], n_ele_dof, &indices[0], &ele_mat(0,0));
b.SumIntoGlobalValues(n_ele_dof, &indices[0], &ele_rhs(0));
}
A.GlobalAssemble();
b.GlobalAssemble();
std::cout << "OK!" << std::endl;
/// 准备解向量。
Epetra_FEVector x(map);
/// 加上狄氏边值条件
u_int n_bnd_dof = 0; /// 首先清点边界上自由度的个数
for (u_int i = 0;i < fem_space.n_dof();++ i) {
if (fem_space.dofBoundaryMark(i) > 0) {
/// 如果不是在主几何体上就不做
if (! global_index.is_dof_on_primary_geometry(i)) continue;
n_bnd_dof += 1;
}
}
/// 准备空间存储边界上全局标号、自变量和右端项
std::vector<int> bnd_idx(n_bnd_dof);
std::vector<double> x_entry(n_bnd_dof), rhs_entry(n_bnd_dof);
/// 对自由度做循环
for (u_int i = 0, j = 0;i < fem_space.n_dof();++ i) {
if (fem_space.dofBoundaryMark(i) > 0) { /// 边界上的自由度?
/// 如果不是在主几何体上就不做
if (! global_index.is_dof_on_primary_geometry(i)) continue;
const int& idx = global_index(i); /// 行的全局标号
bnd_idx[j] = idx;
/// 修改矩阵
int lrid = A.LRID(idx);
int row_nnz, *row_idx;
double *row_entry, row_diag;
A.ExtractMyRowView(lrid, row_nnz, row_entry, row_idx); /// 取出矩阵的行
for (int k = 0;k < row_nnz;++ k) { /// 对矩阵的行进行修改
if (A.LCID(row_idx[k]) != lrid) { /// 如果不是对角元
row_entry[k] = 0.0; /// 则将矩阵元素清零
} else { /// 而对角元保持不变
row_diag = row_entry[k]; /// 并记录下对角元
}
}
/// 计算并记下自变量和右端项，假设自由度值为插值量
double u_b_val = _u_b_(fem_space.dofInfo(i).interp_point);
x_entry[j] = u_b_val;
rhs_entry[j] = row_diag*u_b_val;
j += 1;
}
}
std::cout << "# DOF on the boundary: " << n_bnd_dof << std::endl;
/// 修改解变量和右端项
x.ReplaceGlobalValues(n_bnd_dof, &bnd_idx[0], &x_entry[0]);
b.ReplaceGlobalValues(n_bnd_dof, &bnd_idx[0], &rhs_entry[0]);
/// 调用 AztecOO 的求解器。
std::cout << "Solving the linear system ..." << std::flush;
Epetra_LinearProblem problem(&A, &x, &b);
AztecOO solver(problem);
ML_Epetra::MultiLevelPreconditioner precond(A, true);
solver.SetPrecOperator(&precond);
solver.SetAztecOption(AZ_solver, AZ_gmres);
solver.SetAztecOption(AZ_output, 100);
solver.Iterate(5000, 1.0e-12);
std::cout << "OK!" << std::endl;
Epetra_Map fe_map(-1, global_index.n_local_dof(), &global_index(0), 0, comm);
FEMFunction<double,DIM> u_h(fem_space);
Epetra_Import importer(fe_map, map);
Epetra_Vector X(View, fe_map, &u_h(0));
X.Import(x, importer, Add);
char filename[1024];
sprintf(filename, "u_h%d.dx", forest.rank());
u_h.writeOpenDXData(filename);
MPI_Finalize();
return 0;
}
int main(int argc, char * argv[])
{
typedef MPI::HGeometryForest<DIM,DOW> forest_t;
typedef MPI::BirdView<forest_t> ir_mesh_t;
typedef FEMSpace<double,DIM,DOW> fe_space_t;
typedef MPI::DOF::GlobalIndex<forest_t, fe_space_t> global_index_t;
PetscInitialize(&argc, &argv, (char *)NULL, help);
forest_t forest(PETSC_COMM_WORLD);
forest.readMesh(argv[1]);
ir_mesh_t ir_mesh(forest);
int round = 0;
if (argc >= 3) round = atoi(argv[2]);
ir_mesh.globalRefine(round);
ir_mesh.semiregularize();
ir_mesh.regularize(false);
setenv("AFEPACK_TEMPLATE_PATH", "/usr/local/AFEPack/template/triangle", 1);
TemplateGeometry<DIM> tri;
tri.readData("triangle.tmp_geo");
CoordTransform<DIM,DIM> tri_ct;
tri_ct.readData("triangle.crd_trs");
TemplateDOF<DIM> tri_td(tri);
tri_td.readData("triangle.1.tmp_dof");
BasisFunctionAdmin<double,DIM,DIM> tri_bf(tri_td);
tri_bf.readData("triangle.1.bas_fun");
std::vector<TemplateElement<double,DIM,DIM> > tmp_ele(1);
tmp_ele[0].reinit(tri, tri_td, tri_ct, tri_bf);
RegularMesh<DIM,DOW>& mesh = ir_mesh.regularMesh();
fe_space_t fem_space(mesh, tmp_ele);
u_int n_ele = mesh.n_geometry(DIM);
fem_space.element().resize(n_ele);
for (int i = 0;i < n_ele;i ++) {
fem_space.element(i).reinit(fem_space, i, 0);
}
fem_space.buildElement();
fem_space.buildDof();
fem_space.buildDofBoundaryMark();
std::cout << "Building global indices ... " << std::flush;
global_index_t global_index(forest, fem_space);
global_index.build();
std::cout << "OK!" << std::endl;
std::cout << "Building the linear system ... " << std::flush;
Mat A;
Vec x, b;
MatCreateMPIAIJ(PETSC_COMM_WORLD,
global_index.n_primary_dof(), global_index.n_primary_dof(),
PETSC_DECIDE, PETSC_DECIDE,
0, PETSC_NULL, 0, PETSC_NULL, &A);
VecCreateMPI(PETSC_COMM_WORLD, global_index.n_primary_dof(), PETSC_DECIDE, &b);
fe_space_t::ElementIterator
the_ele = fem_space.beginElement(),
end_ele = fem_space.endElement();
for (;the_ele != end_ele;++ the_ele) {
double vol = the_ele->templateElement().volume();
const QuadratureInfo<DIM>& qi = the_ele->findQuadratureInfo(5);
std::vector<Point<DIM> > q_pnt = the_ele->local_to_global(qi.quadraturePoint());
int n_q_pnt = qi.n_quadraturePoint();
std::vector<double> jac = the_ele->local_to_global_jacobian(qi.quadraturePoint());
std::vector<std::vector<double> > bas_val = the_ele->basis_function_value(q_pnt);
std::vector<std::vector<std::vector<double> > > bas_grad = the_ele->basis_function_gradient(q_pnt);
const std::vector<int>& ele_dof = the_ele->dof();
u_int n_ele_dof = ele_dof.size();
FullMatrix<double> ele_mat(n_ele_dof, n_ele_dof);
Vector<double> ele_rhs(n_ele_dof);
for (u_int l = 0;l < n_q_pnt;++ l) {
double JxW = vol*jac[l]*qi.weight(l);
double f_val = _f_(q_pnt[l]);
for (u_int i = 0;i < n_ele_dof;++ i) {
for (u_int j = 0;j < n_ele_dof;++ j) {
ele_mat(i, j) += JxW*(bas_val[i][l]*bas_val[j][l] +
innerProduct(bas_grad[i][l], bas_grad[j][l]));
}
ele_rhs(i) += JxW*f_val*bas_val[i][l];
}
}
/**
* 此处将单元矩阵和单元载荷先计算好，然后向全局的矩阵和载荷向量上
* 集中，可以提高效率。
*/
std::vector<int> indices(n_ele_dof);
for (u_int i = 0;i < n_ele_dof;++ i) {
indices[i] = global_index(ele_dof[i]);
}
MatSetValues(A, n_ele_dof, &indices[0], n_ele_dof, &indices[0], &ele_mat(0,0), ADD_VALUES);
VecSetValues(b, n_ele_dof, &indices[0], &ele_rhs(0), ADD_VALUES);
}
MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY);
MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY);
VecAssemblyBegin(b);
VecAssemblyEnd(b);
std::cout << "OK!" << std::endl;
/// 加上狄氏边值条件
std::cout << "Applying the Dirichlet boundary condition ... " << std::flush;
u_int n_bnd_dof = 0; /// 首先清点边界上自由度的个数
for (u_int i = 0;i < fem_space.n_dof();++ i) {
if (fem_space.dofBoundaryMark(i) > 0) {
/// 如果不是在主几何体上就不做
if (! global_index.is_dof_on_primary_geometry(i)) continue;
n_bnd_dof += 1;
}
}
/// 准备空间存储边界上全局标号、自变量和右端项
std::vector<int> bnd_idx(n_bnd_dof);
std::vector<double> rhs_entry(n_bnd_dof);
/// 对自由度做循环
for (u_int i = 0, j = 0;i < fem_space.n_dof();++ i) {
if (fem_space.dofBoundaryMark(i) > 0) { /// 边界上的自由度?
/// 如果不是在主几何体上就不做
if (! global_index.is_dof_on_primary_geometry(i)) continue;
bnd_idx[j] = global_index(i); /// 行的全局标号
/// 计算并记下自变量和右端项，假设自由度值为插值量
double u_b_val = _u_b_(fem_space.dofInfo(i).interp_point);
rhs_entry[j] = u_b_val;
j += 1;
}
}
/// 将矩阵修改为对角元 1.0，其它元素为零的状态
/// MatSetOption(A, MAT_KEEP_ZEROED_ROWS);
MatZeroRows(A, n_bnd_dof, &bnd_idx[0], 1.0);
/// 修改右端项为相应点的边值
Vec rhs_bnd;
VecCreateSeqWithArray(PETSC_COMM_SELF, n_bnd_dof, &rhs_entry[0], &rhs_bnd);
IS is_bnd;
ISCreateGeneralWithArray(PETSC_COMM_WORLD, n_bnd_dof, &bnd_idx[0], &is_bnd);
VecScatter bnd_scatter;
VecScatterCreate(rhs_bnd, PETSC_NULL, b, is_bnd, &bnd_scatter);
VecScatterBegin(bnd_scatter, rhs_bnd, b, INSERT_VALUES, SCATTER_FORWARD);
VecScatterEnd(bnd_scatter, rhs_bnd, b, INSERT_VALUES, SCATTER_FORWARD);
VecDestroy(rhs_bnd);
ISDestroy(is_bnd);
VecScatterDestroy(bnd_scatter);
std::cout << "OK!" << std::endl;
VecDuplicate(b, &x);
KSP solver;
KSPCreate(PETSC_COMM_WORLD, &solver);
KSPSetOperators(solver, A, A, SAME_NONZERO_PATTERN);
KSPSetType(solver, KSPGMRES);
KSPSetFromOptions(solver);
KSPSolve(solver, b, x);
if (forest.rank() == 0) {
KSPConvergedReason reason;
KSPGetConvergedReason(solver,&reason);
if (reason == KSP_DIVERGED_INDEFINITE_PC) {
printf("\nDivergence because of indefinite preconditioner;\n");
printf("Run the executable again but with -pc_ilu_shift option.\n");
} else if (reason<0) {
printf("\nOther kind of divergence: this should not happen.\n");
} else {
PetscInt its;
KSPGetIterationNumber(solver,&its);
printf("\nConvergence in %d iterations.\n",(int)its);
}
printf("\n");
}
MatDestroy(A);
VecDestroy(b);
KSPDestroy(solver);
FEMFunction<double,DIM> u_h(fem_space);
Vec X;
VecCreateSeqWithArray(PETSC_COMM_SELF, global_index.n_local_dof(), &u_h(0), &X);
std::vector<int> primary_idx(global_index.n_primary_dof());
global_index.build_primary_index(&primary_idx[0]);
IS is;
ISCreateGeneralWithArray(PETSC_COMM_WORLD, global_index.n_local_dof(),
&global_index(0), &is);
VecScatter scatter;
VecScatterCreate(x, is, X, PETSC_NULL, &scatter);
VecScatterBegin(scatter, x, X, INSERT_VALUES, SCATTER_FORWARD);
VecScatterEnd(scatter, x, X, INSERT_VALUES, SCATTER_FORWARD);
VecDestroy(x);
VecDestroy(X);
VecScatterDestroy(scatter);
ISDestroy(is);
char filename[1024];
sprintf(filename, "u_h%d.dx", forest.rank());
u_h.writeOpenDXData(filename);
PetscFinalize();
return 0;
}
