int main()
{
typedef double numeric_type;
typedef viennagrid::tetrahedral_3d_mesh DomainType;
typedef viennagrid::result_of::segmentation<DomainType>::type SegmentationType;
typedef viennagrid::result_of::cell_tag<DomainType>::type CellTag;
typedef viennagrid::result_of::element<DomainType, CellTag>::type CellType;
typedef viennadata::storage<> StorageType;
typedef viennagrid::result_of::element_range<DomainType, CellTag>::type CellContainer;
typedef viennagrid::result_of::iterator<CellContainer>::type CellIterator;
typedef viennagrid::result_of::vertex_range<CellType>::type VertexOnCellContainer;
typedef viennagrid::result_of::iterator<VertexOnCellContainer>::type VertexOnCellIterator;
typedef viennamath::function_symbol FunctionSymbol;
typedef viennamath::equation Equation;
typedef viennafvm::boundary_key BoundaryKey;
//
// Create a domain from file
//
DomainType domain;
SegmentationType segmentation(domain);
StorageType storage;
try
{
viennagrid::io::netgen_reader my_netgen_reader;
my_netgen_reader(domain, segmentation, "../examples/data/cube3072.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
// Specify Poisson equation:
viennafvm::ncell_quantity<CellType, viennamath::expr::interface_type> permittivity; permittivity.wrap_constant( storage, permittivity_key() );
FunctionSymbol u(0, viennamath::unknown_tag<>()); //an unknown function used for PDE specification
Equation poisson_eq = viennamath::make_equation( viennamath::div(permittivity * viennamath::grad(u)), -1); // \Delta u = -1
//
// Setting boundary information on domain (this should come from device specification)
//
//setting some boundary flags:
viennagrid::result_of::default_point_accessor<DomainType>::type point_accessor = viennagrid::default_point_accessor(domain);
viennadata::result_of::accessor<StorageType, permittivity_key, double, CellType>::type permittivity_accessor =
viennadata::make_accessor(storage, permittivity_key());
viennadata::result_of::accessor<StorageType, BoundaryKey, bool, CellType>::type boundary_accessor =
viennadata::make_accessor(storage, BoundaryKey( u.id() ));
CellContainer cells(domain);
for (CellIterator cit = cells.begin();
cit != cells.end();
++cit)
{
bool cell_on_boundary = false;
// write dummy permittivity to cells:
permittivity_accessor(*cit) = 1.0;
VertexOnCellContainer vertices(*cit);
for (VertexOnCellIterator vit = vertices.begin();
vit != vertices.end();
++vit)
{
//boundary for first equation: Homogeneous Dirichlet everywhere
if (point_accessor(*vit)[0] == 0.0 || point_accessor(*vit)[0] == 1.0
|| point_accessor(*vit)[2] == 0.0 || point_accessor(*vit)[2] == 1.0 )
{
cell_on_boundary = true;
break;
}
}
boundary_accessor(*cit) = cell_on_boundary;
}
//
// Setup Linear Solver
//
viennafvm::linsolv::viennacl linear_solver;
//
// Create PDE solver instance
//
viennafvm::pde_solver<> pde_solver;
//
// Pass system to solver:
//
pde_solver(viennafvm::make_linear_pde_system(poisson_eq, u), // PDE with associated unknown
domain,
storage, linear_solver);
//
// Writing solution back to domain (discussion about proper way of returning a solution required...)
//
viennafvm::io::write_solution_to_VTK_file(pde_solver.result(), "poisson_3d", domain, segmentation, storage, 0);
std::cout << "*****************************************" << std::endl;
std::cout << "* Poisson solver finished successfully! *" << std::endl;
std::cout << "*****************************************" << std::endl;
return EXIT_SUCCESS;
}
int main()
{
typedef viennagrid::triangular_2d_mesh DomainType;
typedef viennagrid::result_of::segmentation<DomainType>::type SegmentationType;
typedef SegmentationType::iterator SegmentationIteratorType;
typedef viennagrid::result_of::segment_handle<SegmentationType>::type SegmentType;
typedef viennagrid::result_of::cell_tag<DomainType>::type CellTagType;
typedef viennagrid::result_of::element<DomainType, viennagrid::vertex_tag>::type VertexType;
typedef viennagrid::result_of::element<DomainType, CellTagType>::type CellType;
typedef viennagrid::result_of::element_range<DomainType, viennagrid::vertex_tag>::type VertexContainerType;
typedef viennagrid::result_of::iterator<VertexContainerType>::type VertexIteratorType;
typedef viennagrid::result_of::element_range<SegmentType, CellTagType>::type CellOnSegmentContainerType;
typedef viennagrid::result_of::iterator<CellOnSegmentContainerType>::type CellOnSegmentIteratorType;
typedef boost::numeric::ublas::compressed_matrix<viennafem::numeric_type> MatrixType;
typedef boost::numeric::ublas::vector<viennafem::numeric_type> VectorType;
typedef viennamath::function_symbol FunctionSymbol;
typedef viennamath::equation Equation;
//
// Create a domain from file
//
DomainType my_domain;
SegmentationType segments(my_domain);
//
// Create a storage object
//
typedef viennadata::storage<> StorageType;
StorageType storage;
try
{
viennagrid::io::netgen_reader my_netgen_reader;
my_netgen_reader(my_domain, segments, "../examples/data/square224.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
//
// Specify Poisson equation with inhomogeneous permittivity:
//
FunctionSymbol u(0, viennamath::unknown_tag<>()); //an unknown function used for PDE specification
FunctionSymbol v(0, viennamath::test_tag<>()); //an unknown function used for PDE specification
viennafem::cell_quan<CellType, viennamath::expr::interface_type> permittivity; permittivity.wrap_constant( storage, permittivity_key() );
//the strong form (not yet functional because of ViennaMath limitations)
//Equation poisson_equ = viennamath::make_equation( viennamath::div(permittivity * viennamath::grad(u)), 0);
//the weak form:
Equation poisson_equ = viennamath::make_equation(
viennamath::integral(viennamath::symbolic_interval(),
permittivity * (viennamath::grad(u) * viennamath::grad(v)) ),
0);
MatrixType system_matrix;
VectorType load_vector;
//
// Setting boundary information on domain (this should come from device specification)
//
//setting some boundary flags:
VertexContainerType vertices = viennagrid::elements<VertexType>(my_domain);
for (VertexIteratorType vit = vertices.begin();
vit != vertices.end();
++vit)
{
// Boundary condition: 0 at left boundary, 1 at right boundary
if ( viennagrid::point(my_domain, *vit)[0] == 0.0)
viennafem::set_dirichlet_boundary(storage, *vit, 0.0);
else if ( viennagrid::point(my_domain, *vit)[0] == 1.0)
viennafem::set_dirichlet_boundary(storage, *vit, 1.0);
}
//
// Create PDE solver functors: (discussion about proper interface required)
//
viennafem::pde_assembler<StorageType> fem_assembler(storage);
//
// Solve system and write solution vector to pde_result:
// (discussion about proper interface required. Introduce a pde_result class?)
//
std::size_t si = 0;
for(SegmentationIteratorType sit = segments.begin(); sit != segments.end(); sit++)
{
//set permittivity:
CellOnSegmentContainerType cells = viennagrid::elements<CellType>(*sit);
for (CellOnSegmentIteratorType cit = cells.begin();
cit != cells.end();
++cit)
{
if (si == 0) //Si
viennadata::access<permittivity_key, double>(storage, permittivity_key(), *cit) = 3.9;
else //SiO2
viennadata::access<permittivity_key, double>(storage, permittivity_key(), *cit) = 11.9;
}
fem_assembler(viennafem::make_linear_pde_system(poisson_equ,
u,
viennafem::make_linear_pde_options(0,
viennafem::lagrange_tag<1>(),
viennafem::lagrange_tag<1>())
),
*sit,
system_matrix,
load_vector
);
}
VectorType pde_result = viennacl::linalg::solve(system_matrix, load_vector, viennacl::linalg::cg_tag());
std::cout << "* solve(): Residual: " << norm_2(prod(system_matrix, pde_result) - load_vector) << std::endl;
//
// Writing solution back to domain (discussion about proper way of returning a solution required...)
//
viennafem::io::write_solution_to_VTK_file(pde_result, "poisson_cellquan_2d", my_domain, segments, storage, 0);
std::cout << "*****************************************" << std::endl;
std::cout << "* Poisson solver finished successfully! *" << std::endl;
std::cout << "*****************************************" << std::endl;
return EXIT_SUCCESS;
}
int main()
{
typedef viennagrid::line_1d_mesh MeshType;
typedef viennagrid::result_of::segmentation<MeshType>::type SegmentationType;
typedef viennamath::function_symbol FunctionSymbol;
typedef viennamath::equation Equation;
//
// Create a mesh from file
//
MeshType mesh;
SegmentationType segmentation(mesh);
try
{
viennagrid::io::netgen_reader my_netgen_reader;
my_netgen_reader(mesh, segmentation, "../examples/data/line23.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
//
// Create problem description
//
viennafvm::problem_description<MeshType> problem_desc(mesh);
// Initialize unknowns:
typedef viennafvm::problem_description<MeshType>::quantity_type QuantityType;
QuantityType & quan = problem_desc.add_quantity("u");
viennafvm::set_dirichlet_boundary(quan, segmentation(1), 0.0);
viennafvm::set_dirichlet_boundary(quan, segmentation(5), 1.0);
viennafvm::set_unknown(quan, segmentation(2));
viennafvm::set_unknown(quan, segmentation(3));
viennafvm::set_unknown(quan, segmentation(4));
QuantityType & quan_permittivity = problem_desc.add_quantity("permittivity", 3);
viennafvm::set_initial_value(quan_permittivity, segmentation(3), 1.0);
viennafvm::set_initial_value(quan_permittivity, segmentation(4), 1.0);
viennafvm::set_initial_value(quan_permittivity, segmentation(5), 1.0);
// Specify Poisson equation:
FunctionSymbol u(0, viennamath::unknown_tag<>()); //an unknown function used for PDE specification
FunctionSymbol permittivity(1);
Equation poisson_eq = viennamath::make_equation( viennamath::div(permittivity * viennamath::grad(u)), 0); // \Delta u = 0
//
// Setup Linear Solver
//
viennafvm::linsolv::viennacl linear_solver;
//
// Pass system to solver:
//
viennafvm::pde_solver my_solver;
my_solver(problem_desc,
viennafvm::make_linear_pde_system(poisson_eq, u), // PDE with associated unknown
linear_solver);
//
// Writing solution back to mesh (discussion about proper way of returning a solution required...)
//
viennafvm::io::write_solution_to_VTK_file(problem_desc.quantities(), "poisson_1d", mesh, segmentation);
std::cout << "*****************************************" << std::endl;
std::cout << "* Poisson solver finished successfully! *" << std::endl;
std::cout << "*****************************************" << std::endl;
return EXIT_SUCCESS;
}
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;
}
