int main(int argc, char * argv[])
{
MPI_Init(&argc, &argv);
forest_t forest(MPI_COMM_WORLD);
u_int round = 1;
if (argc >= 3) {
round = atoi(argv[2]); /// 第二个参数是随机加密的轮数
}
ir_mesh_t ir_mesh(forest);
load_balancer_t hlb(forest);
MPI::load_mesh("tmp", forest, ir_mesh);
/// 第一个参数是周期描述文件
MPI::Periodic::periodizeForest(forest, argv[1]);
for (u_int i = 0;i < round;++ i) {
ir_mesh.randomRefine(20.0); /// 加密 5% 的单元
}
ir_mesh.semiregularize();
ir_mesh.regularize(false);
char filename[256];
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
sprintf(filename, "mesh%d.dx", rank);
ir_mesh.regularMesh().writeOpenDXData(filename);
MPI_Finalize();
return 0;
}
int main(int argc, char* argv[]) {
std::random_device rnd_device;
std::mt19937 rng(rnd_device());
std::unique_ptr<Forest> forest(new Forest(1, 300));
std::stringstream filename;
for(size_t L : {
50, 100, 200, 300
}) {
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
forest->Resize(L);
filename << "./data/clustersize/" << L << ".txt";
filename.flush();
std::ofstream file(filename.str());
for(double p=0.1; p<=0.9; p+=0.05) {
forest->Fill(p, rng);
file << p << "\t" << forest->biggestCluster() << std::endl;
}
file.flush();
file.close();
std::cout << filename.str() << " written." << std::endl;
filename.str(std::string());
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
std::cout << "This one (L=" << L << ") took "
<< std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count()
<< " ms." << std::endl;
}
return 0;
}
main()
{
initwindow (800, 600); // ¬ключить графику и создать окно
forest(100);
getch();
closegraph();
}
void FrameTreeWidget::rebuild()
{
mTreeWidget->clear();
FrameForest forest(mPatientService->getDatas());
QDomElement root = forest.getDocument().documentElement();
this->fill(mTreeWidget->invisibleRootItem(), root);
mTreeWidget->expandToDepth(10);
mTreeWidget->resizeColumnToContents(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);
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);
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();
global_index_t global_index(forest, fem_space);
global_index.build();
MPI_Finalize();
return 0;
}
void beginning(character* user)
{
//INTRO
printf("You step foot into a village with nothing but the clothes on your back.\n");
printf("The last thing you remembered before blacking out was a tree with golden orbs hanging from its branches.\n");
printf("In order to learn more about what happened, you decided to go in search of that tree.\n");
printf("Do you decide to ask the villagers for help (1) or do you turn back and proceed the opposite direction (2)?\n");
scanf("%d", &answer2);
if (answer2 == 1)
else
forest(user);
}
int main(int argc, char * argv[])
{
MPI_Init(&argc, &argv);
typedef MPI::HGeometryForest<DIM,DOW> forest_t;
forest_t forest(MPI_COMM_WORLD);
if (argc < 3) {
system("head -n 20 ex29.cpp");
MPI_Finalize();
return 1;
}
u_int global_round = 1;
if (argc >= 3) {
global_round = atoi(argv[2]); /// 第二个参数是全局加密的轮数
}
int n_new_rank = forest.n_rank();
if (argc >= 4) {
n_new_rank = atoi(argv[3]); /// 第三个参数是新分区的分区个数
}
forest.readMesh(argv[1]); /// 第一个参数是网格文件名
MPI::BirdView<forest_t> ir_mesh(forest);
ir_mesh.globalRefine(global_round);
ir_mesh.semiregularize();
ir_mesh.regularize(false);
/// 移除背景单元
ir_mesh.eraseRootElement(global_round);
forest.eraseRootElement(global_round);
forest.renumerateRootElement(&map);
MPI::HLoadBalance<forest_t> hlb(forest);
hlb.config(ir_mesh);
hlb.partition(n_new_rank);
Migration::initialize(forest.communicator());
MPI::BirdViewSet<forest_t> bvs;
bvs.add(ir_mesh);
hlb.save_data("tmp", bvs);
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[]) {
// deterministic (repeatable) randomness
// GLOBAL_mtrand = MTRand(37);
// "real" randomness
GLOBAL_mtrand = MTRand((unsigned)time(0));
//
ArgParser args(argc, argv);
Mesh mesh(&args);
Hemisphere hemisphere(&mesh, 10, 30);
Forest forest(&args, &hemisphere);
mesh.Load(args.input_file);
glutInit(&argc,argv);
GLCanvas::initialize(&args,&mesh,&hemisphere,&forest);
return 0;
}
int main(int argc, char * argv[])
{
MPI_Init(&argc, &argv);
forest_t forest(MPI_COMM_WORLD);
forest.readMesh(argv[1]); /// 第一个参数是网格文件名
MPI::BirdView<forest_t> ir_mesh(forest);
u_int round = atoi(argv[2]); /// 第二个参数是随机加密的轮数
for (u_int i = 0;i < round;++ i) {
ir_mesh.randomRefine(20.0); /// 加密 5% 的单元
}
ir_mesh.semiregularize();
ir_mesh.regularize();
char filename[256];
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
sprintf(filename, "mesh%d.dx", rank);
ir_mesh.regularMesh().writeOpenDXData(filename);
MPI_Finalize();
return 0;
}
static constexpr decltype(auto) apply(X&& x)
{ return node(std::forward<X>(x), forest()); }
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;
}
void binspector_html_dump(std::istream& input,
auto_forest_t aforest,
std::ostream& output,
const std::string& coutput,
const std::string& cerrput)
{
inspection_forest_t& forest(*aforest);
inspection_branch_t begin(adobe::leading_of(forest.begin()));
inspection_branch_t end(adobe::trailing_of(forest.begin()));
bitreader_t bitreader(input);
output << "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n"
<< "<html>\n"
<< "<head>\n"
<< "<title>Binspector</title>\n"
<< "<meta http-equiv=\"Content-Type\" content=\"text/html;charset=utf-8\"/>\n"
<< "<link rel=\"stylesheet\" type=\"text/css\" href=\"http://fonts.googleapis.com/css?family=Ubuntu|Ubuntu+Mono|Mate+SC\"/>\n"
<< "<link rel='stylesheet' type='text/css' href='http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.16/themes/blitzer/jquery-ui.css'/>\n"
<< "<script type='text/javascript' src='https://ajax.googleapis.com/ajax/libs/jquery/1.7.0/jquery.min.js'></script>\n"
<< "<script type='text/javascript' src='https://ajax.googleapis.com/ajax/libs/jqueryui/1.8.16/jquery-ui.min.js'></script>\n"
<< "<script type='text/javascript'>$(function(){\n"
<< " $('.tip_region').each(function()\n"
<< " {\n"
<< " var tip = $(this).find('.tip');\n"
<< "\n"
<< " $(this).hover(\n"
<< " function() { tip.appendTo('body'); },\n"
<< " function() { tip.appendTo(this); }\n"
<< " ).mousemove(function(e)\n"
<< " {\n"
<< " tip.css({ left: 0, top: $(window).scrollTop() });\n"
<< " });\n"
<< " });\n"
<< " $('li').each(function()\n"
<< " {\n"
<< " $(this).click(function(e)\n"
<< " {\n"
<< " e.stopPropagation();\n"
<< "\n"
<< " if ($(this).hasClass('atomic'))\n"
<< " return;\n"
<< "\n"
<< " if ($(this).hasClass('open'))\n"
<< " {\n"
<< " $(this).removeClass('open');\n"
<< " $(this).addClass('collapsed');\n"
<< " $(this).children().not(':first').hide();\n"
<< " }\n"
<< " else\n"
<< " {\n"
<< " $(this).removeClass('collapsed');\n"
<< " $(this).addClass('open');\n"
<< " $(this).children().show();\n"
<< " }\n"
<< " });\n"
<< " });\n"
<< "});</script>\n"
<< "<style type='text/css'>\n"
<< "body\n"
<< " {\n"
<< " font-family: \"Ubuntu Mono\", Monaco, monospace;\n"
<< " font-size: 14pt;\n"
<< " }\n"
<< "ul\n"
<< " {\n"
<< " list-style: none;\n"
<< " margin-left: 0;\n"
<< " padding-left: 1em;\n"
<< " text-indent: -1em;\n"
<< " cursor: pointer;\n"
<< " }\n"
<< "li\n"
<< " {\n"
<< " background: white;\n"
<< " }\n"
<< "li:hover\n"
<< " {\n"
<< " background: #d0dafd;\n"
<< " }\n"
<< ".collapsed:before\n"
<< " {\n"
<< " content: \"+ \";\n"
<< " }\n"
<< ".open:before\n"
<< " {\n"
<< " content: \"- \";\n"
<< " }\n"
<< ".atomic\n"
<< " {\n"
<< " padding-left: 1em;\n"
<< " }\n"
<< ".collapsed li\n"
<< " {\n"
<< " display: none;\n"
<< " }\n"
<< "pre.stdout\n"
<< " {\n"
<< " background: #eee;\n"
<< " padding: 10px;\n"
<< " }\n"
<< "pre.stderr\n"
<< " {\n"
<< " background: #fbb;\n"
<< " padding: 10px;\n"
<< " }\n"
<< ".detailed\n"
<< " {\n"
<< " color: #339;\n"
<< " }\n"
<< ".alpha\n"
<< " {\n"
<< " background: white;\n"
<< " }\n"
<< ".beta\n"
<< " {\n"
<< " background: white;\n"
<< " }\n"
<< ".tip\n"
<< " {\n"
<< " border: 2px solid black;\n"
<< " background: yellow;\n"
<< " padding: 10px;\n"
<< " position: absolute;\n"
<< " z-index: 1000;\n"
<< " -webkit-border-radius: 3px;\n"
<< " -moz-border-radius: 3px;\n"
<< " border-radius: 3px;\n"
<< " }\n"
<< ".tip_region .tip\n"
<< " {\n"
<< " display: none;\n"
<< " }\n"
<< "</style>\n"
<< "</head>\n"
<< "<body>\n"
<< "<h1>Binary File Analysis</h1>\n"
<< "<h2>Notifications</h2>\n"
<< "<pre class='stdout'>\n"
<< (coutput.empty() ? std::string("none") : coutput)
<< "</pre>\n"
<< "<h2>Errors & Warnings</h2>\n"
<< "<pre class='stderr'>\n"
<< (cerrput.empty() ? std::string("none") : cerrput)
<< "</pre>\n"
<< "<h2>Tree</h2>\n"
<< "<ul class='beta'>\n";
for (depth_full_iterator_t iter(begin), last(++end); iter != last; ++iter)
print_node(bitreader, output, forest, iter);
output << "</ul>\n";
output << "</body>\n";
output << "</html>\n";
}
int main()
{
// Test constructor
{
Mercator::Forest mf;
}
// Test constructor
{
Mercator::Forest mf(23);
}
// Test getArea()
{
Mercator::Forest mf;
Mercator::Area * a = mf.getArea();
assert(a == 0);
}
// Test species()
{
Mercator::Forest mf;
Mercator::Forest::PlantSpecies & mps = mf.species();
assert(mps.empty());
}
{
Mercator::Forest forest(4249162ul);
Mercator::Forest::PlantSpecies & species = forest.species();
const Mercator::Forest::PlantStore & plants = forest.getPlants();
// Forest is not yet populated
assert(plants.empty());
assert(species.empty());
forest.populate();
// Forest has zero area, so even when populated it is empty
assert(plants.empty());
assert(species.empty());
Mercator::Area* ar = new Mercator::Area(1, false);
WFMath::Polygon<2> p;
p.addCorner(p.numCorners(), Point2(5, 8));
p.addCorner(p.numCorners(), Point2(40, -1));
p.addCorner(p.numCorners(), Point2(45, 16));
p.addCorner(p.numCorners(), Point2(30, 28));
p.addCorner(p.numCorners(), Point2(-2, 26));
p.addCorner(p.numCorners(), Point2(1, 5));
ar->setShape(p);
forest.setArea(ar);
forest.populate();
// Forest has no species, so even when populated it is empty
assert(plants.empty());
assert(species.empty());
{
Mercator::Species pine;
pine.m_probability = 0.04;
pine.m_deviation = 1.f;
species.push_back(pine);
}
forest.populate();
// Forest should now contain some plants
assert(!plants.empty());
dumpPlants(plants);
int plant_count = countPlants(plants);
{
Mercator::Species oak;
oak.m_probability = 0.02;
oak.m_deviation = 1.f;
species.push_back(oak);
}
forest.populate();
// Forest should now contain some plants
assert(!plants.empty());
assert(countPlants(plants) > plant_count);
dumpPlants(plants);
std::cout << countPlants(plants) << "," << plant_count
<< std::endl << std::flush;
}
}