void init_quantities( SegmentationType const & segmentation, StorageType & storage )
{
typedef typename viennagrid::result_of::cell<SegmentationType>::type CellType;
//
// Init permittivity
//
double eps0 = 8.854e-12;
double epsr_silicon = 11.7; // silicon!
double eps_silicon = eps0 * epsr_silicon;
// donator doping
viennafvm::set_quantity_region( segmentation(1), storage, permittivity_key(), false);
viennafvm::set_quantity_region( segmentation(2), storage, permittivity_key(), true);
viennafvm::set_quantity_value( segmentation(2), storage, permittivity_key(), eps_silicon);
viennafvm::set_quantity_region( segmentation(3), storage, permittivity_key(), true);
viennafvm::set_quantity_value( segmentation(3), storage, permittivity_key(), eps_silicon);
viennafvm::set_quantity_region( segmentation(4), storage, permittivity_key(), true);
viennafvm::set_quantity_value( segmentation(4), storage, permittivity_key(), eps_silicon);
viennafvm::set_quantity_region( segmentation(5), storage, permittivity_key(), false);
}
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 double numeric_type;
typedef viennagrid::triangular_2d_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 viennamath::function_symbol FunctionSymbol;
typedef viennamath::equation Equation;
//
// Create a domain from file
//
DomainType domain;
SegmentationType segmentation(domain);
viennadata::storage<> storage;
try
{
viennagrid::io::netgen_reader my_reader;
my_reader(domain, segmentation, "../examples/data/nin2d.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
// for (int i = 0; i < 10; ++i)
// std::cout << "Segment " << i << " - " << segmentation.segment_present(i) << std::endl;
scale_domain(domain, 1e-9);
//
// Assign doping and set initial values
//
init_quantities(segmentation, storage);
//
// Setting boundary information on domain (see mosfet.in2d for segment indices)
//
FunctionSymbol psi(0); // potential, using id=0
// potential:
viennafvm::set_dirichlet_boundary( segmentation(1), storage, psi, 0.0);
viennafvm::set_dirichlet_boundary( segmentation(5), storage, psi, 0.8);
//
// Specify PDEs:
//
viennafvm::ncell_quantity<CellType, viennamath::expr::interface_type> permittivity; permittivity.wrap_constant( storage, permittivity_key() );
// here is all the fun: specify DD system
Equation laplace_eq = viennamath::make_equation( viennamath::div(permittivity * viennamath::grad(psi)), /* = */ 0);
viennafvm::linear_pde_system<> pde_system;
pde_system.add_pde(laplace_eq, psi); // equation and associated quantity
pde_system.is_linear(true);
//
// Setup Linear Solver
//
viennafvm::linsolv::viennacl linear_solver;
//
// Create PDE solver instance and run the solver:
//
viennafvm::pde_solver<> pde_solver;
pde_solver(pde_system, domain, storage, linear_solver); // weird math happening in here ;-)
//
// Writing all solution variables back to domain
//
std::vector<long> result_ids(pde_system.size());
for (std::size_t i=0; i<pde_system.size(); ++i)
result_ids[i] = pde_system.unknown(i)[0].id();
viennafvm::io::write_solution_to_VTK_file(pde_solver.result(), "nin_2d_laplace", domain, segmentation, storage, result_ids);
std::cout << "*************************************" << std::endl;
std::cout << "* Simulation finished successfully! *" << std::endl;
std::cout << "*************************************" << std::endl;
return EXIT_SUCCESS;
}
