void test(std::string outfile)
{
typedef typename viennagrid::result_of::cell_tag<MeshType>::type CellTag;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::line_range<MeshType>::type EdgeContainer;
typedef typename viennagrid::result_of::iterator<EdgeContainer>::type EdgeIterator;
typedef typename viennagrid::result_of::facet_range<MeshType>::type FacetContainer;
typedef typename viennagrid::result_of::iterator<FacetContainer>::type FacetIterator;
typedef typename viennagrid::result_of::cell_range<MeshType>::type CellContainer;
typedef typename viennagrid::result_of::iterator<CellContainer>::type CellIterator;
MeshType mesh;
setup(mesh, CellTag());
std::cout << "Vertices: " << std::endl;
VertexContainer vertices(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
std::cout << *vit << std::endl;
std::cout << "Edges: " << std::endl;
EdgeContainer edges(mesh);
for (EdgeIterator eit = edges.begin();
eit != edges.end();
++eit)
std::cout << *eit << std::endl;
std::cout << "Facets: " << std::endl;
FacetContainer facets(mesh);
for (FacetIterator fit = facets.begin();
fit != facets.end();
++fit)
std::cout << *fit << std::endl;
std::cout << "Cells: " << std::endl;
CellContainer cells(mesh);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit)
std::cout << *cit << std::endl;
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
my_vtk_writer(mesh, outfile);
}
int main()
{
typedef viennagrid::line_1d_mesh MeshType;
std::cout << "* main(): Creating mesh..." << std::endl;
MeshType mesh;
//create mesh:
setup_mesh(mesh);
typedef viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef viennagrid::result_of::line<MeshType>::type EdgeType;
typedef viennagrid::result_of::cell<MeshType>::type CellType;
typedef viennagrid::result_of::const_cell_handle<MeshType>::type ConstCellHandleType;
std::deque<double> interface_areas;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > interface_contributions;
std::deque<double> vertex_box_volumes;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > vertex_box_volume_contributions;
std::deque<double> edge_box_volumes;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > edge_box_volume_contributions;
//set up dual grid info:
viennagrid::apply_voronoi<CellType>(
mesh,
viennagrid::make_accessor<EdgeType>(interface_areas),
viennagrid::make_accessor<EdgeType>(interface_contributions),
viennagrid::make_accessor<VertexType>(vertex_box_volumes),
viennagrid::make_accessor<VertexType>(vertex_box_volume_contributions),
viennagrid::make_accessor<EdgeType>(edge_box_volumes),
viennagrid::make_accessor<EdgeType>(edge_box_volume_contributions)
);
//output results:
output_voronoi_info(mesh,
viennagrid::make_accessor<VertexType>(vertex_box_volumes), viennagrid::make_accessor<VertexType>(vertex_box_volume_contributions),
viennagrid::make_accessor<EdgeType>(interface_areas), viennagrid::make_accessor<EdgeType>(interface_contributions));
std::cout << std::endl;
std::cout << viennagrid::cells(mesh)[0] << std::endl;
std::cout << std::endl;
std::cout << "Circumcenter of cell #0: " << viennagrid::circumcenter(viennagrid::cells(mesh)[0]) << std::endl;
std::cout << "Circumcenter of cell #1: " << viennagrid::circumcenter(viennagrid::cells(mesh)[1]) << std::endl;
std::cout << "Circumcenter of cell #2: " << viennagrid::circumcenter(viennagrid::cells(mesh)[2]) << std::endl;
std::cout << "Circumcenter of cell #3: " << viennagrid::circumcenter(viennagrid::cells(mesh)[3]) << std::endl;
std::cout << "-----------------------" << std::endl;
std::cout << "Centroid of cell #0: " << viennagrid::centroid(viennagrid::cells(mesh)[0]) << std::endl;
std::cout << "Centroid of cell #1: " << viennagrid::centroid(viennagrid::cells(mesh)[1]) << std::endl;
std::cout << "Centroid of cell #2: " << viennagrid::centroid(viennagrid::cells(mesh)[2]) << std::endl;
std::cout << "Centroid of cell #3: " << viennagrid::centroid(viennagrid::cells(mesh)[3]) << std::endl;
// Check Voronoi volumes:
voronoi_volume_check(mesh,
viennagrid::make_accessor<VertexType>(vertex_box_volumes),
viennagrid::make_accessor<VertexType>(vertex_box_volume_contributions),
viennagrid::make_accessor<EdgeType>(edge_box_volume_contributions)
);
//write to vtk:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
my_vtk_writer(mesh, "voronoi_line");
std::cout << "*******************************" << std::endl;
std::cout << "* Test finished successfully! *" << std::endl;
std::cout << "*******************************" << std::endl;
return EXIT_SUCCESS;
}
void test(ReaderType & my_reader, std::string const & infile, std::string const & outfile)
{
typedef typename viennagrid::result_of::segmentation<MeshType>::type SegmentationType;
typedef typename viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef typename viennagrid::result_of::cell<MeshType>::type CellType;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::cell_range<MeshType>::type CellRange;
typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
MeshType mesh;
SegmentationType segmentation(mesh);
try
{
my_reader(mesh, segmentation, infile);
}
catch (std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
exit(EXIT_FAILURE);
}
std::vector<double> vtk_vertex_double_data;
std::vector<double> vtk_vertex_long_data;
std::vector< std::vector<double> > vtk_vertex_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_double_accessor( vtk_vertex_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_long_accessor( vtk_vertex_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, VertexType >::type vtk_vertex_vector_accessor( vtk_vertex_vector_data );
//write some dummy data:
VertexContainer vertices(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
vtk_vertex_double_accessor(*vit) = viennagrid::point(*vit)[0];
vtk_vertex_long_accessor(*vit) = vit->id().get();
vtk_vertex_vector_accessor(*vit).resize(3);
vtk_vertex_vector_accessor(*vit)[0] = viennagrid::point(*vit)[0];
vtk_vertex_vector_accessor(*vit)[1] = viennagrid::point(*vit)[1];
}
std::vector<double> vtk_cell_double_data;
std::vector<double> vtk_cell_long_data;
std::vector< std::vector<double> > vtk_cell_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_double_accessor( vtk_cell_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_long_accessor( vtk_cell_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, CellType >::type vtk_cell_vector_accessor( vtk_cell_vector_data );
int index = 0;
CellRange cells(mesh);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit, ++index)
{
vtk_cell_double_accessor(*cit) = viennagrid::centroid(*cit)[0];
vtk_cell_long_accessor(*cit) = cit->id().get();
vtk_cell_vector_accessor(*cit).resize(3);
vtk_cell_vector_accessor(*cit)[0] = viennagrid::centroid(*cit)[0];
vtk_cell_vector_accessor(*cit)[1] = viennagrid::centroid(*cit)[1];
}
//test writers:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_vertices(my_vtk_writer, vtk_vertex_vector_accessor, "data_point");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_vtk_writer, vtk_cell_vector_accessor, "data_point");
my_vtk_writer(mesh, segmentation, outfile);
viennagrid::io::opendx_writer<MeshType> my_dx_writer;
my_dx_writer(mesh, outfile + ".odx");
}
void test_vtk(ReaderType & my_reader, std::string const & infile, std::string const & outfile)
{
typedef typename viennagrid::result_of::segmentation<MeshType>::type SegmentationType;
typedef typename viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef typename viennagrid::result_of::cell<MeshType>::type CellType;
typedef typename viennagrid::result_of::vertex_range<MeshType>::type VertexContainer;
typedef typename viennagrid::result_of::iterator<VertexContainer>::type VertexIterator;
typedef typename viennagrid::result_of::cell_range<MeshType>::type CellRange;
typedef typename viennagrid::result_of::iterator<CellRange>::type CellIterator;
MeshType mesh;
SegmentationType segmentation(mesh);
std::vector<double> vtk_vertex_double_data;
std::vector<double> vtk_vertex_long_data;
std::vector< std::vector<double> > vtk_vertex_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_double_accessor( vtk_vertex_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, VertexType >::type vtk_vertex_long_accessor( vtk_vertex_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, VertexType >::type vtk_vertex_vector_accessor( vtk_vertex_vector_data );
std::vector<double> vtk_cell_double_data;
std::vector<double> vtk_cell_long_data;
std::vector< std::vector<double> > vtk_cell_vector_data;
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_double_accessor( vtk_cell_double_data );
typename viennagrid::result_of::accessor< std::vector<double>, CellType >::type vtk_cell_long_accessor( vtk_cell_long_data );
typename viennagrid::result_of::accessor< std::vector< std::vector<double> >, CellType >::type vtk_cell_vector_accessor( vtk_cell_vector_data );
viennagrid::io::add_scalar_data_on_vertices(my_reader, vtk_vertex_double_accessor, "data_double" );
viennagrid::io::add_scalar_data_on_vertices(my_reader, vtk_vertex_long_accessor, "data_long" );
viennagrid::io::add_vector_data_on_vertices(my_reader, vtk_vertex_vector_accessor, "data_point" );
viennagrid::io::add_scalar_data_on_cells(my_reader, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_reader, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_reader, vtk_cell_vector_accessor, "data_point");
try
{
my_reader(mesh, segmentation, infile);
}
catch (std::exception const & ex)
{
std::cerr << ex.what() << std::endl;
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
exit(EXIT_FAILURE);
}
//write some dummy data:
VertexContainer vertices(mesh);
for (VertexIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
double data_double = vtk_vertex_double_accessor(*vit);
long data_long = static_cast<long>(vtk_vertex_long_accessor(*vit));
std::vector<double> data_point = vtk_vertex_vector_accessor(*vit);
assert( fabs(data_double - viennagrid::point(*vit)[0]) < 1e-4 && "Vertex check failed: data_double!");
assert( (data_long == vit->id().get()) && "Vertex check failed: data_long!");
assert( fabs(data_point[0] - viennagrid::point(*vit)[0]) < 1e-4
&& fabs(data_point[1] - viennagrid::point(*vit)[1]) < 1e-4
&& "Vertex check failed: data_point!");
}
CellRange cells(mesh);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit)
{
double data_double = vtk_cell_double_accessor(*cit);
long data_long = static_cast<long>(vtk_cell_long_accessor(*cit));
std::vector<double> data_point = vtk_cell_vector_accessor(*cit);
assert( fabs(data_double - viennagrid::centroid(*cit)[0]) < 1e-4 && "Cell check failed: data_double!");
assert( (data_long == cit->id().get()) && "Cell check failed: data_long!");
assert( fabs(data_point[0] - viennagrid::centroid(*cit)[0]) < 1e-4
&& fabs(data_point[1] - viennagrid::centroid(*cit)[1]) < 1e-4
&& "Cell check failed: data_point!");
}
//test writers:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_vertices(my_vtk_writer, vtk_vertex_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_vertices(my_vtk_writer, vtk_vertex_vector_accessor, "data_point");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_double_accessor, "data_double");
viennagrid::io::add_scalar_data_on_cells(my_vtk_writer, vtk_cell_long_accessor, "data_long");
viennagrid::io::add_vector_data_on_cells(my_vtk_writer, vtk_cell_vector_accessor, "data_point");
my_vtk_writer(mesh, segmentation, outfile);
viennagrid::io::opendx_writer<MeshType> my_dx_writer;
my_dx_writer(mesh, outfile + ".odx");
}
int main()
{
typedef viennagrid::tetrahedral_3d_mesh MeshType;
typedef viennagrid::tetrahedral_3d_segmentation SegmentationType;
std::cout << "* main(): Creating device..." << std::endl;
MeshType mesh;
SegmentationType segmentation(mesh);
std::string path = "../examples/data/";
//create device:
try
{
viennagrid::io::netgen_reader my_netgen_reader;
my_netgen_reader(mesh, segmentation, path + "cube48.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
typedef viennagrid::result_of::vertex<MeshType>::type VertexType;
typedef viennagrid::result_of::line<MeshType>::type EdgeType;
typedef viennagrid::result_of::cell<MeshType>::type CellType;
typedef viennagrid::result_of::const_cell_handle<MeshType>::type ConstCellHandleType;
std::deque<double> interface_areas;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > interface_contributions;
std::deque<double> vertex_box_volumes;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > vertex_box_volume_contributions;
std::deque<double> edge_box_volumes;
std::deque< viennagrid::result_of::voronoi_cell_contribution<ConstCellHandleType>::type > edge_box_volume_contributions;
//set up dual grid info:
viennagrid::apply_voronoi<CellType>(
mesh,
viennagrid::make_field<EdgeType>(interface_areas),
viennagrid::make_field<EdgeType>(interface_contributions),
viennagrid::make_field<VertexType>(vertex_box_volumes),
viennagrid::make_field<VertexType>(vertex_box_volume_contributions),
viennagrid::make_field<EdgeType>(edge_box_volumes),
viennagrid::make_field<EdgeType>(edge_box_volume_contributions)
);
//output results:
output_voronoi_info(mesh,
viennagrid::make_field<VertexType>(vertex_box_volumes), viennagrid::make_field<VertexType>(vertex_box_volume_contributions),
viennagrid::make_field<EdgeType>(interface_areas), viennagrid::make_field<EdgeType>(interface_contributions));
std::cout << std::endl;
std::cout << viennagrid::cells(mesh)[0] << std::endl;
std::cout << std::endl;
std::cout << "Circumcenter of first cell: " << viennagrid::circumcenter(viennagrid::cells(mesh)[0]) << std::endl;
// Check Voronoi volumes:
voronoi_volume_check(mesh,
viennagrid::make_field<VertexType>(vertex_box_volumes),
viennagrid::make_field<VertexType>(vertex_box_volume_contributions),
viennagrid::make_field<EdgeType>(edge_box_volume_contributions)
);
//write to vtk:
viennagrid::io::vtk_writer<MeshType> my_vtk_writer;
my_vtk_writer(mesh, segmentation, "voronoi_tet");
std::cout << "*******************************" << std::endl;
std::cout << "* Test finished successfully! *" << std::endl;
std::cout << "*******************************" << std::endl;
return EXIT_SUCCESS;
}
