743 *
return (material == 1 ? epsilon_1 : epsilon_2);
747 * std::complex<double> Parameters<dim>::mu_inv(
const Point<dim> & ,
750 *
return (material == 1 ? mu_inv_1 : mu_inv_2);
754 *
typename Parameters<dim>::rank2_type
759 *
return (left == right ? rank2_type() : sigma_tensor);
763 *
typename Parameters<dim>::rank1_type
767 *
const auto distance = (dipole_position -
point).
norm() / dipole_radius;
771 *
std::cos(distance * M_PI / 2.) / (M_PI / 2. - 2. / M_PI) /
772 * dipole_radius / dipole_radius;
773 * J_a = dipole_strength * dipole_orientation *
scale;
780 * <a name=
"step_81-PerfectlyMatchedLayerClass"></a>
781 * <h4>PerfectlyMatchedLayer Class</h4>
783 * implements the transformation matrices
used to modify the permittivity
784 * and permeability tensors supplied from the Parameters
class. The
785 * actual transformation of the material tensors will be done in the
786 * assembly
loop. The radii and the strength of the PML is specified, and
787 * the coefficients will be modified
using transformation matrices within
788 * the PML region. The radii and strength of the PML are editable through
789 * a .prm file. The rotation
function @f$T_{exer}@f$ is the same as
790 * introduced in the perfectly matched layer section of the introduction.
791 * Similarly, the matrices A, B and
C are defined as follows
793 * A = T_{e_xe_r}^{-1}
794 * \text{diag}\left(\frac{1}{\bar{
d}^2},\frac{1}{d\bar{
d}}\right)T_{e_xe_r},\qquad
795 * B = T_{e_xe_r}^{-1} \text{diag}\left(d,\bar{
d}\right)T_{e_xe_r},\qquad
796 *
C = T_{e_xe_r}^{-1} \text{diag}\left(\frac{1}{\bar{
d}},\frac{1}{
d}\right)
808 *
static_assert(dim == 2,
809 *
"The perfectly matched layer is only implemented in 2d.");
811 * Parameters<dim> parameters;
817 * PerfectlyMatchedLayer();
821 * std::complex<double> d_bar(
const Point<dim> point);
824 * rank2_type rotation(std::complex<double> d_1,
825 * std::complex<double> d_2,
828 * rank2_type a_matrix(
const Point<dim> point);
830 * rank2_type b_matrix(
const Point<dim> point);
832 * rank2_type c_matrix(
const Point<dim> point);
835 *
double inner_radius;
836 *
double outer_radius;
842 * PerfectlyMatchedLayer<dim>::PerfectlyMatchedLayer()
845 * inner_radius = 12.;
846 * add_parameter(
"inner radius",
848 *
"inner radius of the PML shell");
849 * outer_radius = 20.;
850 * add_parameter(
"outer radius",
852 *
"outer radius of the PML shell");
854 * add_parameter(
"strength", strength,
"strength of the PML");
859 *
typename std::complex<double>
860 * PerfectlyMatchedLayer<dim>::d(
const Point<dim> point)
863 *
if (radius > inner_radius)
866 * strength * ((radius - inner_radius) * (radius - inner_radius)) /
867 * ((outer_radius - inner_radius) * (outer_radius - inner_radius));
878 *
typename std::complex<double>
879 * PerfectlyMatchedLayer<dim>::d_bar(
const Point<dim> point)
882 *
if (radius > inner_radius)
884 *
const double s_bar =
886 * ((radius - inner_radius) * (radius - inner_radius) *
887 * (radius - inner_radius)) /
888 * (radius * (outer_radius - inner_radius) *
889 * (outer_radius - inner_radius));
890 *
return {1.0, s_bar};
900 *
typename PerfectlyMatchedLayer<dim>::rank2_type
901 * PerfectlyMatchedLayer<dim>::rotation(std::complex<double> d_1,
902 * std::complex<double> d_2,
907 * result[0][1] =
point[0] *
point[1] * (d_1 - d_2);
908 * result[1][0] =
point[0] *
point[1] * (d_1 - d_2);
915 *
typename PerfectlyMatchedLayer<dim>::rank2_type
916 * PerfectlyMatchedLayer<dim>::a_matrix(
const Point<dim> point)
918 *
const auto d = this->d(point);
919 *
const auto d_bar = this->d_bar(point);
920 *
return invert(rotation(d * d, d * d_bar, point)) *
921 * rotation(d * d, d * d_bar, point);
926 *
typename PerfectlyMatchedLayer<dim>::rank2_type
927 * PerfectlyMatchedLayer<dim>::b_matrix(
const Point<dim> point)
929 *
const auto d = this->d(point);
930 *
const auto d_bar = this->d_bar(point);
931 *
return invert(rotation(d, d_bar, point)) * rotation(d, d_bar, point);
936 *
typename PerfectlyMatchedLayer<dim>::rank2_type
937 * PerfectlyMatchedLayer<dim>::c_matrix(
const Point<dim> point)
939 *
const auto d = this->d(point);
940 *
const auto d_bar = this->d_bar(point);
941 *
return invert(rotation(1. / d_bar, 1. / d, point)) *
942 * rotation(1. / d_bar, 1. / d, point);
949 * <a name=
"step_81-MaxwellClass"></a>
950 * <h4>Maxwell Class</h4>
951 * At
this point we are ready to declare all the major building blocks of
952 * the finite element program which consists of the usual setup and
953 * assembly routines. Most of the structure has already been introduced
954 * in previous tutorial programs. The Maxwell
class also holds private
955 * instances of the Parameters and PerfectlyMatchedLayers classes
956 * introduced above. The
default values of these parameters are
set to
957 * show us a standing wave with absorbing boundary conditions and a PML.
973 *
unsigned int refinements;
974 *
unsigned int fe_order;
975 *
unsigned int quadrature_order;
976 *
bool absorbing_boundary;
978 *
void parse_parameters_callback();
980 *
void setup_system();
981 *
void assemble_system();
983 *
void output_results();
985 * Parameters<dim> parameters;
986 * PerfectlyMatchedLayer<dim> perfectly_matched_layer;
991 * std::unique_ptr<FiniteElement<dim>> fe;
1003 * <a name=
"step_81-ClassTemplateDefinitionsandImplementation"></a>
1004 * <h3>Class Template Definitions and Implementation</h3>
1009 * <a name=
"step_81-TheConstructor"></a>
1010 * <h4>The Constructor</h4>
1011 * The Constructor simply consists of
default initialization a number of
1012 * discretization parameters (such as the domain size, mesh refinement,
1013 * and the order of finite elements and quadrature) and declaring a
1015 * these can be modified by editing the .prm file. Absorbing boundary
1016 * conditions can be controlled with the absorbing_boundary
boolean. If
1017 * absorbing boundary conditions are disabled we simply enforce
1018 * homogeneous Dirichlet conditions on the tangential component of the
1019 * electric field. In the context of time-harmonic Maxwell
's equations
1020 * these are also known as perfectly conducting boundary conditions.
1026 * template <int dim>
1027 * Maxwell<dim>::Maxwell()
1028 * : ParameterAcceptor("Maxwell")
1029 * , dof_handler(triangulation)
1031 * ParameterAcceptor::parse_parameters_call_back.connect(
1032 * [&]() { parse_parameters_callback(); });
1035 * add_parameter("scaling", scaling, "scale of the hypercube geometry");
1038 * add_parameter("refinements",
1040 * "number of refinements of the geometry");
1043 * add_parameter("fe order", fe_order, "order of the finite element space");
1045 * quadrature_order = 1;
1046 * add_parameter("quadrature order",
1048 * "order of the quadrature");
1050 * absorbing_boundary = true;
1051 * add_parameter("absorbing boundary condition",
1052 * absorbing_boundary,
1053 * "use absorbing boundary conditions?");
1057 * template <int dim>
1058 * void Maxwell<dim>::parse_parameters_callback()
1060 * fe = std::make_unique<FESystem<dim>>(FE_NedelecSZ<dim>(fe_order), 2);
1065 * The Maxwell::make_grid() routine creates the mesh for the
1066 * computational domain which in our case is a scaled square domain.
1067 * Additionally, a material interface is introduced by setting the
1068 * material id of the upper half (@f$y>0@f$) to 1 and of the lower half
1069 * (@f$y<0@f$) of the computational domain to 2.
1070 * We are using a block decomposition into real and imaginary matrices
1071 * for the solution matrices. More details on this are available
1072 * under the Results section.
1078 * template <int dim>
1079 * void Maxwell<dim>::make_grid()
1081 * GridGenerator::hyper_cube(triangulation, -scaling, scaling);
1082 * triangulation.refine_global(refinements);
1084 * if (!absorbing_boundary)
1086 * for (auto &face : triangulation.active_face_iterators())
1087 * if (face->at_boundary())
1088 * face->set_boundary_id(1);
1091 * for (auto &cell : triangulation.active_cell_iterators())
1092 * if (cell->center()[1] > 0.)
1093 * cell->set_material_id(1);
1095 * cell->set_material_id(2);
1098 * std::cout << "Number of active cells: " << triangulation.n_active_cells()
1104 * The Maxwell::setup_system() routine follows the usual routine of
1105 * enumerating all the degrees of freedom and setting up the matrix and
1106 * vector objects to hold the system data. Enumerating is done by using
1107 * DoFHandler::distribute_dofs().
1113 * template <int dim>
1114 * void Maxwell<dim>::setup_system()
1116 * dof_handler.distribute_dofs(*fe);
1117 * std::cout << "Number of degrees of freedom: " << dof_handler.n_dofs()
1120 * solution.reinit(dof_handler.n_dofs());
1121 * system_rhs.reinit(dof_handler.n_dofs());
1123 * constraints.clear();
1125 * DoFTools::make_hanging_node_constraints(dof_handler, constraints);
1127 * VectorTools::project_boundary_values_curl_conforming_l2(
1129 * 0, /* real part */
1130 * Functions::ZeroFunction<dim>(2 * dim),
1131 * 0, /* boundary id */
1133 * VectorTools::project_boundary_values_curl_conforming_l2(
1135 * dim, /* imaginary part */
1136 * Functions::ZeroFunction<dim>(2 * dim),
1137 * 0, /* boundary id */
1140 * constraints.close();
1142 * DynamicSparsityPattern dsp(dof_handler.n_dofs(), dof_handler.n_dofs());
1143 * DoFTools::make_sparsity_pattern(dof_handler,
1146 * /* keep_constrained_dofs = */ true);
1147 * sparsity_pattern.copy_from(dsp);
1148 * system_matrix.reinit(sparsity_pattern);
1153 * This is a helper function that takes the tangential component of a tensor.
1156 * template <int dim>
1157 * DEAL_II_ALWAYS_INLINE inline Tensor<1, dim, std::complex<double>>
1158 * tangential_part(const Tensor<1, dim, std::complex<double>> &tensor,
1159 * const Tensor<1, dim> &normal)
1161 * auto result = tensor;
1162 * result[0] = normal[1] * (tensor[0] * normal[1] - tensor[1] * normal[0]);
1163 * result[1] = -normal[0] * (tensor[0] * normal[1] - tensor[1] * normal[0]);
1170 * Assemble the stiffness matrix and the right-hand side:
1172 * A_{ij} = \int_\Omega (\mu_r^{-1}\nabla \times \varphi_j) \cdot
1173 * (\nabla\times\bar{\varphi}_i)\text{d}x
1174 * - \int_\Omega \varepsilon_r\varphi_j \cdot \bar{\varphi}_i\text{d}x
1175 * - i\int_\Sigma (\sigma_r^{\Sigma}(\varphi_j)_T) \cdot
1176 * (\bar{\varphi}_i)_T\text{do}x
1177 * - i\int_{\partial\Omega} (\sqrt{\mu_r^{-1}\varepsilon}(\varphi_j)_T) \cdot
1178 * (\nabla\times(\bar{\varphi}_i)_T)\text{d}x, \f} \f{align}{
1179 * F_i = i\int_\Omega J_a \cdot \bar{\varphi_i}\text{d}x - \int_\Omega
1180 * \mu_r^{-1} \cdot (\nabla \times \bar{\varphi_i}) \text{d}x.
1182 * In addition, we will be modifying the coefficients if the position of the
1183 * cell is within the PML region.
1189 * template <int dim>
1190 * void Maxwell<dim>::assemble_system()
1192 * QGauss<dim> quadrature_formula(quadrature_order);
1193 * QGauss<dim - 1> face_quadrature_formula(quadrature_order);
1195 * FEValues<dim, dim> fe_values(*fe,
1196 * quadrature_formula,
1197 * update_values | update_gradients |
1198 * update_quadrature_points |
1199 * update_JxW_values);
1200 * FEFaceValues<dim, dim> fe_face_values(*fe,
1201 * face_quadrature_formula,
1202 * update_values | update_gradients |
1203 * update_quadrature_points |
1204 * update_normal_vectors |
1205 * update_JxW_values);
1207 * const unsigned int dofs_per_cell = fe->dofs_per_cell;
1209 * const unsigned int n_q_points = quadrature_formula.size();
1210 * const unsigned int n_face_q_points = face_quadrature_formula.size();
1212 * FullMatrix<double> cell_matrix(dofs_per_cell, dofs_per_cell);
1213 * Vector<double> cell_rhs(dofs_per_cell);
1214 * std::vector<types::global_dof_index> local_dof_indices(dofs_per_cell);
1218 * Next, let us assemble on the interior of the domain on the left hand
1219 * side. So we are computing
1221 * \int_\Omega (\mu_r^{-1}\nabla \times \varphi_i) \cdot
1222 * (\nabla\times\bar{\varphi}_j)\text{d}x
1224 * \int_\Omega \varepsilon_r\varphi_i \cdot \bar{\varphi}_j\text{d}x
1228 * i\int_\Omega J_a \cdot \bar{\varphi_i}\text{d}x
1229 * - \int_\Omega \mu_r^{-1} \cdot (\nabla \times \bar{\varphi_i})
1232 * In doing so, we need test functions @f$\varphi_i@f$ and @f$\varphi_j@f$, and the
1233 * curl of these test variables. We must be careful with the signs of the
1234 * imaginary parts of these complex test variables. Moreover, we have a
1235 * conditional that changes the parameters if the cell is in the PML region.
1238 * const FEValuesExtractors::Vector real_part(0);
1239 * const FEValuesExtractors::Vector imag_part(dim);
1240 * for (const auto &cell : dof_handler.active_cell_iterators())
1242 * fe_values.reinit(cell);
1247 * cell->get_dof_indices(local_dof_indices);
1248 * const auto id = cell->material_id();
1250 * const auto &quadrature_points = fe_values.get_quadrature_points();
1252 * for (unsigned int q_point = 0; q_point < n_q_points; ++q_point)
1254 * const Point<dim> &position = quadrature_points[q_point];
1256 * auto mu_inv = parameters.mu_inv(position, id);
1257 * auto epsilon = parameters.epsilon(position, id);
1258 * const auto J_a = parameters.J_a(position, id);
1260 * const auto A = perfectly_matched_layer.a_matrix(position);
1261 * const auto B = perfectly_matched_layer.b_matrix(position);
1262 * const auto d = perfectly_matched_layer.d(position);
1264 * mu_inv = mu_inv / d;
1265 * epsilon = invert(A) * epsilon * invert(B);
1267 * for (const auto i : fe_values.dof_indices())
1269 * constexpr std::complex<double> imag{0., 1.};
1271 * const auto phi_i =
1272 * fe_values[real_part].value(i, q_point) -
1273 * imag * fe_values[imag_part].value(i, q_point);
1274 * const auto curl_phi_i =
1275 * fe_values[real_part].curl(i, q_point) -
1276 * imag * fe_values[imag_part].curl(i, q_point);
1278 * const auto rhs_value =
1279 * (imag * scalar_product(J_a, phi_i)) * fe_values.JxW(q_point);
1280 * cell_rhs(i) += rhs_value.real();
1282 * for (const auto j : fe_values.dof_indices())
1284 * const auto phi_j =
1285 * fe_values[real_part].value(j, q_point) +
1286 * imag * fe_values[imag_part].value(j, q_point);
1287 * const auto curl_phi_j =
1288 * fe_values[real_part].curl(j, q_point) +
1289 * imag * fe_values[imag_part].curl(j, q_point);
1292 * (scalar_product(mu_inv * curl_phi_j, curl_phi_i) -
1293 * scalar_product(epsilon * phi_j, phi_i)) *
1294 * fe_values.JxW(q_point);
1295 * cell_matrix(i, j) += temp.real();
1302 * Now we assemble the face and the boundary. The following loops will
1305 * - i\int_\Sigma (\sigma_r^{\Sigma}(\varphi_i)_T) \cdot
1306 * (\bar{\varphi}_j)_T\text{do}x \f} and \f{align}{
1307 * - i\int_{\partial\Omega} (\sqrt{\mu_r^{-1}\varepsilon}(\varphi_i)_T)
1308 * \cdot (\nabla\times(\bar{\varphi}_j)_T)\text{d}x,
1310 * respectively. The test variables and the PML are implemented
1311 * similarly as the domain.
1314 * const FEValuesExtractors::Vector real_part(0);
1315 * const FEValuesExtractors::Vector imag_part(dim);
1316 * for (const auto &face : cell->face_iterators())
1318 * if (face->at_boundary())
1320 * const auto id = face->boundary_id();
1323 * fe_face_values.reinit(cell, face);
1325 * for (unsigned int q_point = 0; q_point < n_face_q_points;
1328 * const auto &position = quadrature_points[q_point];
1330 * auto mu_inv = parameters.mu_inv(position, id);
1331 * auto epsilon = parameters.epsilon(position, id);
1334 * perfectly_matched_layer.a_matrix(position);
1336 * perfectly_matched_layer.b_matrix(position);
1337 * const auto d = perfectly_matched_layer.d(position);
1339 * mu_inv = mu_inv / d;
1340 * epsilon = invert(A) * epsilon * invert(B);
1342 * const auto normal =
1343 * fe_face_values.normal_vector(q_point);
1345 * for (const auto i : fe_face_values.dof_indices())
1347 * constexpr std::complex<double> imag{0., 1.};
1349 * const auto phi_i =
1350 * fe_face_values[real_part].value(i, q_point) -
1352 * fe_face_values[imag_part].value(i, q_point);
1353 * const auto phi_i_T = tangential_part(phi_i, normal);
1355 * for (const auto j : fe_face_values.dof_indices())
1357 * const auto phi_j =
1358 * fe_face_values[real_part].value(j, q_point) +
1360 * fe_face_values[imag_part].value(j, q_point);
1361 * const auto phi_j_T =
1362 * tangential_part(phi_j, normal) *
1363 * fe_face_values.JxW(q_point);
1365 * const auto prod = mu_inv * epsilon;
1366 * const auto sqrt_prod = prod;
1369 * -imag * scalar_product((sqrt_prod * phi_j_T),
1371 * cell_matrix(i, j) += temp.real();
1381 * We are on an interior face:
1384 * const auto face_index = cell->face_iterator_to_index(face);
1386 * const auto id1 = cell->material_id();
1387 * const auto id2 = cell->neighbor(face_index)->material_id();
1390 * continue; /* skip this face */
1392 * fe_face_values.reinit(cell, face);
1394 * for (unsigned int q_point = 0; q_point < n_face_q_points;
1397 * const auto &position = quadrature_points[q_point];
1399 * auto sigma = parameters.sigma(position, id1, id2);
1401 * const auto B = perfectly_matched_layer.b_matrix(position);
1402 * const auto C = perfectly_matched_layer.c_matrix(position);
1403 * sigma = invert(C) * sigma * invert(B);
1405 * const auto normal = fe_face_values.normal_vector(q_point);
1407 * for (const auto i : fe_face_values.dof_indices())
1409 * constexpr std::complex<double> imag{0., 1.};
1411 * const auto phi_i =
1412 * fe_face_values[real_part].value(i, q_point) -
1413 * imag * fe_face_values[imag_part].value(i, q_point);
1414 * const auto phi_i_T = tangential_part(phi_i, normal);
1416 * for (const auto j : fe_face_values.dof_indices())
1418 * const auto phi_j =
1419 * fe_face_values[real_part].value(j, q_point) +
1421 * fe_face_values[imag_part].value(j, q_point);
1422 * const auto phi_j_T = tangential_part(phi_j, normal);
1426 * scalar_product((sigma * phi_j_T), phi_i_T) *
1427 * fe_face_values.JxW(q_point);
1428 * cell_matrix(i, j) += temp.real();
1435 * constraints.distribute_local_to_global(
1436 * cell_matrix, cell_rhs, local_dof_indices, system_matrix, system_rhs);
1442 * We use a direct solver from the SparseDirectUMFPACK to solve the system
1445 * template <int dim>
1446 * void Maxwell<dim>::solve()
1448 * SparseDirectUMFPACK A_direct;
1449 * A_direct.initialize(system_matrix);
1450 * A_direct.vmult(solution, system_rhs);
1455 * The output is written into a vtk file with 4 components
1458 * template <int dim>
1459 * void Maxwell<dim>::output_results()
1461 * DataOut<2> data_out;
1462 * data_out.attach_dof_handler(dof_handler);
1463 * data_out.add_data_vector(solution,
1464 * {"real_Ex", "real_Ey", "imag_Ex", "imag_Ey"});
1465 * data_out.build_patches();
1466 * std::ofstream output("solution.vtk");
1467 * data_out.write_vtk(output);
1471 * template <int dim>
1472 * void Maxwell<dim>::run()
1476 * assemble_system();
1481 * } // namespace Step81
1485 * The following main function calls the class @ref step_81 "step-81"(), initializes the
1486 * ParameterAcceptor, and calls the run() function.
1496 * using namespace dealii;
1498 * Step81::Maxwell<2> maxwell_2d;
1499 * ParameterAcceptor::initialize("parameters.prm");
1502 * catch (std::exception &exc)
1504 * std::cerr << std::endl
1506 * << "----------------------------------------------------"
1508 * std::cerr << "Exception on processing: " << std::endl
1509 * << exc.what() << std::endl
1510 * << "Aborting!" << std::endl
1511 * << "----------------------------------------------------"
1517 * std::cerr << std::endl
1519 * << "----------------------------------------------------"
1521 * std::cerr << "Unknown exception!" << std::endl
1522 * << "Aborting!" << std::endl
1523 * << "----------------------------------------------------"
1530<a name="step_81-Results"></a><h1>Results</h1>
1533The solution is written to a .vtk file with four components. These are the
1534real and imaginary parts of the @f$E_x@f$ and @f$E_y@f$ solution waves. With the
1535current setup, the output should read
1538Number of active cells: 4096
1539Number of degrees of freedom: 16640
1540Program ended with exit code: 0
1543<a name="step_81-AbsorbingboundaryconditionsandthePML"></a><h3> Absorbing boundary conditions and the PML </h3>
1546The following images are the outputs for the imaginary @f$E_x@f$ without the
1547interface and with the dipole centered at @f$(0,0)@f$. In order to remove the
1548interface, the surface conductivity is set to 0. First, we turn off the
1549absorbing boundary conditions and the PML. Second, we want to see the
1550effect of the PML when absorbing boundary conditions apply. So we set
1551absorbing boundary conditions to true and leave the PML strength to 0.
1552Lastly, we increase the strength of the PML to 4. Change the following in
1556# use absorbing boundary conditions?
1557 set absorbing boundary condition = false
1559# position of the dipole
1560 set dipole position = 0, 0
1562# strength of the PML
1565# surface conductivity between material 1 and material 2
1566 set sigma = 0, 0; 0, 0| 0, 0; 0, 0
1569Following are the output images:
1571<table width="80%" align="center">
1574 <img src="https://www.dealii.org/images/steps/developer/step-81-nointerface_noabs_PML0.png" alt="Visualization of the solution of step-81 with no interface, Dirichlet boundary conditions and PML strength 0" height="210"/>
1575 <p> Solution with no interface, Dirichlet boundary conditions and PML strength 0.</p>
1579 <img src="https://www.dealii.org/images/steps/developer/step-81-nointerface_abs_PML0.png" alt="Visualization of the solution of step-81 with no interface, absorbing boundary conditions and PML strength 0" height="210">
1580 <p> Solution with no interface, absorbing boundary conditions and PML strength 0.</p>
1584 <img src="https://www.dealii.org/images/steps/developer/step-81-nointerface_abs_PML4.png" alt="Visualization of the solution of step-81 with no interface, absorbing boundary conditions and PML strength 4" height="210">
1585 <p> Solution with no interface, absorbing boundary conditions and PML strength 4.</p>
1590We observe that with absorbing boundary conditions and in absence of the
1591PML, there is a lot of distortion and resonance (the real parts will not be
1592generated without a PML). This is, as we stipulated, due to reflection from
1593infinity. As we see, a much more coherent image is generated with an
1596<a name="step_81-SurfacePlasmonPolariton"></a><h3> Surface Plasmon Polariton </h3>
1598Now, let's generate a standing wave by adding an
interface at the
center.
1599In order to observe this effect, we offset the
center of the dipole to @f$(0,
16000.8)@f$ and
set the surface conductivity back to @f$(0.001, 0.2)@f$:
1603# position of the dipole
1604 set dipole position = 0, 0.8
1606# surface conductivity between material 1 and material 2
1607 set sigma = 0.001, 0.2; 0, 0| 0, 0; 0.001, 0.2
1610Once again, we will visualize the output with absorbing boundary conditions
1611and PML strength 0 and with absorbing boundary conditions and PML strength
16124. The following tables are the imaginary part of @f$E_x@f$ and the real part
1615<table width=
"80%" align=
"center">
1618 <img src=
"https://www.dealii.org/images/steps/developer/step-81-imagEx_noabs_PML0.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1619 <
p> Solution with an interface, Dirichlet boundary conditions and PML strength 0.</
p>
1623 <img src=
"https://www.dealii.org/images/steps/developer/step-81-imagEx_abs_PML0.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1624 <
p> Solution with an interface, absorbing boundary conditions and PML strength 0.</
p>
1628 <img src=
"https://www.dealii.org/images/steps/developer/step-81-imagEx_abs_PML4.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 4" height=
"210">
1629 <
p> Solution with an interface, absorbing boundary conditions and PML strength 4.</
p>
1635<table width=
"80%" align=
"center">
1638 <img src=
"https://www.dealii.org/images/steps/developer/step-81-realEx_noabs_PML0.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1639 <
p> Solution with an interface, Dirichlet boundary conditions and PML strength 0.</
p>
1643 <img src=
"https://www.dealii.org/images/steps/developer/step-81-realEx_abs_PML0.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1644 <
p> Solution with an interface, absorbing boundary conditions and PML strength 0.</
p>
1648 <img src=
"https://www.dealii.org/images/steps/developer/step-81-realEx_abs_PML4.png" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 4" height=
"210">
1649 <
p> Solution with an interface, absorbing boundary conditions and PML strength 4.</
p>
1654The SPP is confined near the
interface that we created, however without
1655absorbing boundary conditions, we don't observe a dissipation effect. On
1656adding the absorbing boundary conditions, we observe distortion and
1657resonance and we still don't notice any dissipation. As expected, the PML
1658removes the distortion and resonance. The standing wave is also dissipating
1659and getting absorbed within the PML, and as we increase the PML strength,
1660the standing wave will dissipate more within the PML ring.
1662Here are some animations to demonstrate the effect of the PML
1663<table width=
"80%" align=
"center">
1666 <img src=
"https://www.dealii.org/images/steps/developer/step-81-dirichlet_Ex.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1667 <
p> Solution with an interface, Dirichlet boundary conditions and PML strength 0.</
p>
1671 <img src=
"https://www.dealii.org/images/steps/developer/step-81-absorbing_Ex.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1672 <
p> Solution with an interface, absorbing boundary conditions and PML strength 0.</
p>
1676 <img src=
"https://www.dealii.org/images/steps/developer/step-81-perfectly_matched_layer_Ex.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 4" height=
"210">
1677 <
p> Solution with an interface, absorbing boundary conditions and PML strength 4.</
p>
1683<table width=
"80%" align=
"center">
1686 <img src=
"https://www.dealii.org/images/steps/developer/step-81-dirichlet_Ey.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1687 <
p> Solution with an interface, Dirichlet boundary conditions and PML strength 0.</
p>
1691 <img src=
"https://www.dealii.org/images/steps/developer/step-81-absorbing_Ey.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 0" height=
"210">
1692 <
p> Solution with an interface, absorbing boundary conditions and PML strength 0.</
p>
1696 <img src=
"https://www.dealii.org/images/steps/developer/step-81-perfectly_matched_layer_Ey.gif" alt=
"Visualization of the solution of step-81 with an interface, absorbing boundary conditions and PML strength 4" height=
"210">
1697 <
p> Solution with an interface, absorbing boundary conditions and PML strength 4.</
p>
1702<a name=
"step_81-Notes"></a><h3> Notes </h3>
1705<a name=
"step_81-RealandComplexMatrices"></a><h4> Real and Complex Matrices </h4>
1707As is evident from the results, we are splitting our solution matrices into
1708the real and the imaginary components. We started off
using the @f$H^{curl}@f$
1709conforming Nédélec Elements, and we made two copies of the Finite Elements
1710in order to represent the real and the imaginary components of our input
1712issues present in traditional Nédélec elements). In the assembly, we create
1713two vectors of dimension @f$dim@f$ that assist us in extracting the real and
1714the imaginary components of our finite elements.
1717<a name=
"step_81-RotationsandScaling"></a><h4> Rotations and Scaling </h4>
1719As we see in our assembly, our finite element is rotated and scaled as
1723const auto phi_i =
real_part.value(i, q_point) - 1.0i * imag_part.value(i, q_point);
1726This @f$\phi_i@f$ variable doesn
't need to be scaled in this way, we may choose
1727any arbitrary scaling constants @f$a@f$ and @f$b@f$. If we choose this scaling, the
1728@f$\phi_j@f$ must also be modified with the same scaling, as follows:
1731const auto phi_i = a*real_part.value(i, q_point) -
1732 bi * imag_part.value(i, q_point);
1734const auto phi_j = a*real_part.value(i, q_point) +
1735 bi * imag_part.value(i, q_point);
1738Moreover, the cell_rhs need not be the real part of the rhs_value. Say if
1739we modify to take the imaginary part of the computed rhs_value, we must
1740also modify the cell_matrix accordingly to take the imaginary part of temp.
1741However, making these changes to both sides of the equation will not affect
1742our solution, and we will still be able to generate the surface plasmon
1746cell_rhs(i) += rhs_value.imag();
1748cell_matrix(i) += temp.imag();
1751<a name="step_81-Postprocessing"></a><h4> Postprocessing </h4>
1753We will create a video demonstrating the wave in motion, which is
1754essentially an implementation of @f$e^{-i\omega t}(Re(E) + i*Im(E))@f$ as we
1755increment time. This is done by slightly changing the output function to
1756generate a series of .vtk files, which will represent out solution wave as
1757we increment time. Introduce an input variable @f$t@f$ in the output_results()
1758class as output_results(unsigned int t). Then change the class itself to
1763void Maxwell<dim>::output_results(unsigned int t)
1765 std::cout << "Running step:" << t << std::endl;
1766 DataOut<2> data_out;
1767 data_out.attach_dof_handler(dof_handler);
1768 Vector<double> postprocessed;
1769 postprocessed.reinit(solution);
1770 for (unsigned int i = 0; i < dof_handler.n_dofs(); ++i)
1774 postprocessed[i] = std::cos(2 * M_PI * 0.04 * t) * solution[i] -
1775 std::sin(2 * M_PI * 0.04 * t) * solution[i + 1];
1777 else if (i % 4 == 2)
1779 postprocessed[i] = std::cos(2 * M_PI * 0.04 * t) * solution[i] -
1780 std::sin(2 * M_PI * 0.04 * t) * solution[i + 1];
1783 data_out.add_data_vector(postprocessed, {"E_x", "E_y", "null0", "null1"});
1784 data_out.build_patches();
1785 const std::string filename =
1786 "solution-" + Utilities::int_to_string(t) + ".vtk";
1787 std::ofstream output(filename);
1788 data_out.write_vtk(output);
1789 std::cout << "Done running step:" << t << std::endl;
1793Finally, in the run() function, replace output_results() with
1795for (int t = 0; t <= 100; t++)
1801This would generate 100 solution .vtk files, which can be opened in a group
1802on Paraview and then can be saved as an animation. We used FFMPEG to
1805<a name="step_81-PossibilitiesforExtension"></a><h3> Possibilities for Extension </h3>
1808The example step could be extended in a number of different directions.
1811 The current program uses a direct solver to solve the linear system.
1812 This is efficient for two spatial dimensions where scattering problems
1813 up to a few millions degrees of freedom can be solved. In 3D, however,
1814 the increased stencil size of the Nedelec element pose a severe
1815 limiting factor on the problem size that can be computed. As an
1816 alternative, the idea to use iterative solvers can be entertained.
1817 This, however requires specialized preconditioners. For example, just
1818 using an iterative Krylov space solver (such as SolverGMRES) on above
1819 problem will requires many thousands of iterations to converge.
1820 Unfortunately, time-harmonic Maxwell's equations lack the usual notion
1821 of local smoothing properties, which renders the usual suspects, such
1822 as a geometric multigrid (see the
Multigrid class), largely useless. A
1823 possible extension would be to implement an additive Schwarz preconditioner
1824 (based on domain decomposition, see
for example
1825 @cite Gopalakrishnan2003), or a sweeping preconditioner (see
for
1826 example @cite Ying2012).
1829 Another possible extension of the current program is to introduce local
1830 mesh refinement (either based on a residual estimator, or based on the
1831 dual weighted residual method, see @ref step_14
"step-14"). This is in particular of
1832 interest to counter the increased computational cost caused by the
1833 scale separation between the SPP and the dipole.
1838<a name=
"step_81-PlainProg"></a>
1839<h1> The plain program</h1>
1840@include
"step-81.cc"
void add_parameter(const std::string &entry, ParameterType ¶meter, const std::string &documentation="", ParameterHandler &prm_=prm, const Patterns::PatternBase &pattern= *Patterns::Tools::Convert< ParameterType >::to_pattern())
numbers::NumberTraits< Number >::real_type norm() const
__global__ void set(Number *val, const Number s, const size_type N)
void loop(IteratorType begin, std_cxx20::type_identity_t< IteratorType > end, DOFINFO &dinfo, INFOBOX &info, const std::function< void(DOFINFO &, typename INFOBOX::CellInfo &)> &cell_worker, const std::function< void(DOFINFO &, typename INFOBOX::CellInfo &)> &boundary_worker, const std::function< void(DOFINFO &, DOFINFO &, typename INFOBOX::CellInfo &, typename INFOBOX::CellInfo &)> &face_worker, AssemblerType &assembler, const LoopControl &lctrl=LoopControl())
double norm(const FEValuesBase< dim > &fe, const ArrayView< const std::vector< Tensor< 1, dim > > > &Du)
Point< spacedim > point(const gp_Pnt &p, const double tolerance=1e-10)
SymmetricTensor< 2, dim, Number > C(const Tensor< 2, dim, Number > &F)
SymmetricTensor< 2, dim, Number > d(const Tensor< 2, dim, Number > &F, const Tensor< 2, dim, Number > &dF_dt)
void run(const Iterator &begin, const std_cxx20::type_identity_t< Iterator > &end, Worker worker, Copier copier, const ScratchData &sample_scratch_data, const CopyData &sample_copy_data, const unsigned int queue_length, const unsigned int chunk_size)
const InputIterator OutputIterator const Function & function
::VectorizedArray< Number, width > cos(const ::VectorizedArray< Number, width > &)
const ::parallel::distributed::Triangulation< dim, spacedim > * triangulation
DEAL_II_HOST constexpr SymmetricTensor< 2, dim, Number > invert(const SymmetricTensor< 2, dim, Number > &)