int main()
{
auto obj_fnc = [](const VariableSetPtr& vars) {
auto point = dynamic_cast<Point*>(vars.get());
auto x = point->X;
auto y = point->Y;
double sx = x - 11;
double sy = y - 15;
return sx * sx + sy * sy + 1;
};
auto bounds = Bounds(-1000, 2000, -3000, 2000);
auto simplex1 = SimplexFactory::simplexTriple(obj_fnc, bounds, eArea::SW);
auto simplex2 = SimplexFactory::simplexTriple(obj_fnc, bounds, eArea::SE);
auto simplex3 = SimplexFactory::simplexTriple(obj_fnc, bounds, eArea::NW);
auto simplex4 = SimplexFactory::simplexTriple(obj_fnc, bounds, eArea::NE);
Solver my_solver(obj_fnc);
my_solver.addSimplex(simplex1.get());
my_solver.addSimplex(simplex2.get());
my_solver.addSimplex(simplex3.get());
my_solver.addSimplex(simplex4.get());
double value1(0);
auto var = VariableSetPtr();
my_solver.solve(true, 0.001, var, value1);
std::cout << "Solution is " << var->getVar(0) << " " << var->getVar(1) << '\n';
std::cout << "Value in it " << value1 << '\n';
_getche();
return 0;
}
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::triangular_2d_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_reader;
my_reader(mesh, segmentation, "../examples/data/nin2d.mesh");
}
catch (...)
{
std::cerr << "File-Reader failed. Aborting program..." << std::endl;
return EXIT_FAILURE;
}
viennagrid::scale(mesh, 1e-9); // scale to nanometer
//
// Create PDE solver instance:
//
viennafvm::problem_description<MeshType> problem_desc(mesh);
//
// Assign doping and set initial values
//
init_quantities(segmentation, problem_desc);
//
// Setting boundary information on mesh (see mosfet.in2d for segment indices)
//
FunctionSymbol psi(0); // potential, using id=0
FunctionSymbol permittivity(1); // potential, using id=0
//
// Specify PDEs:
//
// 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;
//
// Run the solver:
//
viennafvm::pde_solver my_solver;
my_solver(problem_desc, pde_system, linear_solver); // weird math happening in here ;-)
//
// Writing all solution variables back to mesh
//
viennafvm::io::write_solution_to_VTK_file(problem_desc.quantities(), "nin_2d_laplace", mesh, segmentation);
std::cout << "*************************************" << std::endl;
std::cout << "* Simulation finished successfully! *" << std::endl;
std::cout << "*************************************" << std::endl;
return EXIT_SUCCESS;
}
