void Permittivity<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
if (is_constant) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
permittivity(cell,qp) = constant_value;
}
}
}
else {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
Teuchos::Array<MeshScalarT> point(numDims);
for (std::size_t i=0; i<numDims; i++)
point[i] = Sacado::ScalarValue<MeshScalarT>::eval(coordVec(cell,qp,i));
if (randField == UNIFORM)
permittivity(cell,qp) = exp_rf_kl->evaluate(point, rv);
else if (randField == LOGNORMAL)
permittivity(cell,qp) = std::exp(exp_rf_kl->evaluate(point, rv));
}
}
}
}
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;
}
nec_float em::impedance() // was (ETA in old nec2)
{
nec_float ret = sqrt(permeability() / permittivity());
return ret; // 376.8
}
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;
}
nec_float em::speed_of_light() // was (CVEL in old nec2) but we have changed it to be in meters per second
{
nec_float ret = 1.0 / sqrt(permeability() * permittivity());
return ret; // 299.8e6;
}
