Hello,
I am trying to use the parallel::distributed::SolutionTransfer<dim,
LinearAlgebra::distributed::Vector<double>, hp::DoFHandler<dim>> class and
I can't seem to use it similarly to the serial version.
I looked through the tests/distributed_grids/solution_transfer_0*.cc tests
and none of them seem to be testing for the hp refinement. The code I'm
working on might be a bit large. Instead, I recreated the errors by copying
the tests/hp/solution_transfer.cc, which contains SolutionTransfer for hp,
and modified it to use the parallel distributed version of it.
Please find attached a proposed test. Line 160-175 are commented out and
does the p-refinement. Therefore, the error below is for h-refinement only,
but with an hp object. Oddly enough, my code works fine for h-refinement,
but I get the same error below when I do p-refinement.
110: --------------------------------------------------------
110: An error occurred in line <401> of file
</home/ddong/Libraries/dealii/source/distributed/solution_transfer.cc> in
function
110: void dealii::parallel::distributed::SolutionTransfer<dim,
VectorType, DoFHandlerType>::unpack_callback(const typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::cell_iterator&, typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::CellStatus, const
boost::iterator_range<__gnu_cxx::__normal_iterator<const char*,
std::vector<char, std::allocator<char> > > >&, std::vector<VectorType*>&)
[with int dim = 2; VectorType =
dealii::LinearAlgebra::distributed::Vector<double>; DoFHandlerType =
dealii::hp::DoFHandler<2, 2>; typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::cell_iterator =
dealii::TriaIterator<dealii::CellAccessor<2, 2> >; typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::CellStatus = dealii::Triangulation<2, 2>::CellStatus]
110: The violated condition was:
110: dof_handler->get_fe(fe_index).dofs_per_cell == it_dofvalues->size()
110: Additional information:
110: The transferred data was packed with a different number of dofs
than thecurrently registered FE object assigned to the DoFHandler has.
110: --------------------------------------------------------
Now, if I uncomment those lines, and therefore do p-refinement in the
attached test, I get
110: --------------------------------------------------------
110: An error occurred in line <382> of file
</home/ddong/Libraries/dealii/source/distributed/solution_transfer.cc> in
function
110: void dealii::parallel::distributed::SolutionTransfer<dim,
VectorType, DoFHandlerType>::unpack_callback(const typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::cell_iterator&, typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::CellStatus, const
boost::iterator_range<__gnu_cxx::__normal_iterator<const char*,
std::vector<char, std::allocator<char> > > >&, std::vector<VectorType*>&)
[with int dim = 2; VectorType =
dealii::LinearAlgebra::distributed::Vector<double>; DoFHandlerType =
dealii::hp::DoFHandler<2, 2>; typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::cell_iterator =
dealii::TriaIterator<dealii::CellAccessor<2, 2> >; typename
dealii::parallel::distributed::Triangulation<dim, DoFHandlerType::
space_dimension>::CellStatus = dealii::Triangulation<2, 2>::CellStatus]
110: The violated condition was:
110: cell->child(child_index)->active_fe_index() == fe_index
110: Additional information:
110: This exception -- which is used in many places in the library --
usually indicates that some condition which the author of the code thought
must be satisfied at a certain point in an algorithm, is not fulfilled. An
example would be that the first part of an algorithm sorts elements of an
array in ascending order, and a second part of the algorithm later
encounters an element that is not larger than the previous one.
110:
110: There is usually not very much you can do if you encounter such an
exception since it indicates an error in deal.II, not in your own program.
Try to come up with the smallest possible program that still demonstrates
the error and contact the deal.II mailing lists with it to obtain help.
110: --------------------------------------------------------
I went through some of the deal.II source code and it's a bit out of my
depth. Please let me know if I am somehow not p-refining correctly, or if I
can be of any help to fix this.
Best regards,
Doug
--
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see
https://groups.google.com/d/forum/dealii?hl=en
---
You received this message because you are subscribed to the Google Groups
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/dealii/1836ac96-4f6c-4d90-ad2f-5e68cbabe623%40googlegroups.com.
// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
#include <deal.II/base/function.h>
#include <deal.II/dofs/dof_accessor.h>
#include <deal.II/dofs/dof_tools.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/mapping_q1.h>
#include <deal.II/grid/grid_generator.h>
#include <deal.II/grid/grid_refinement.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
#include <deal.II/hp/dof_handler.h>
#include <deal.II/hp/fe_collection.h>
#include <deal.II/hp/fe_values.h>
#include <deal.II/lac/vector.h>
#include <deal.II/numerics/data_out.h>
#include <deal.II/numerics/vector_tools.h>
#include <deal.II/distributed/solution_transfer.h>
#include <deal.II/distributed/tria.h>
#include <iostream>
#include <vector>
#include "../tests.h"
// a linear function that should be transferred exactly with Q1 and Q2
// elements
template <int dim>
class MyFunction : public Function<dim>
{
public:
MyFunction()
: Function<dim>(){};
virtual double
value(const Point<dim> &p, const unsigned int) const
{
double f = 0.25 + 2 * p[0];
if (dim > 1)
f += 0.772 * p[1];
if (dim > 2)
f -= 3.112 * p[2];
return f;
};
};
template <int dim>
void
transfer(std::ostream &out)
{
MyFunction<dim> function;
parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
GridGenerator::hyper_cube(tria);
tria.refine_global(5 - dim);
const unsigned int max_degree = 6 - dim;
hp::FECollection<dim> fe_q;
hp::FECollection<dim> fe_dgq;
for (unsigned int deg = 1; deg <= max_degree; ++deg)
{
fe_q.push_back(FE_Q<dim>(deg));
fe_dgq.push_back(FE_DGQ<dim>(deg));
}
hp::DoFHandler<dim> q_dof_handler(tria);
hp::DoFHandler<dim> dgq_dof_handler(tria);
LinearAlgebra::distributed::Vector<double> (q_solution);
LinearAlgebra::distributed::Vector<double> (dgq_solution);
MappingQGeneric<dim> mapping(1);
// refine a few cells
typename Triangulation<dim>::active_cell_iterator cell = tria.begin_active(),
endc = tria.end();
++cell;
++cell;
for (; cell != endc; ++cell)
cell->set_refine_flag();
tria.prepare_coarsening_and_refinement();
tria.execute_coarsening_and_refinement();
// randomly assign FE orders
unsigned int counter = 0;
{
typename hp::DoFHandler<dim>::active_cell_iterator
cell = q_dof_handler.begin_active(),
celldg = dgq_dof_handler.begin_active(), endc = q_dof_handler.end();
for (; cell != endc; ++cell, ++celldg, ++counter)
{
if (counter < 15)
cell->set_active_fe_index(1);
else
cell->set_active_fe_index(Testing::rand() % max_degree);
if (counter < 15)
celldg->set_active_fe_index(1);
else
celldg->set_active_fe_index(Testing::rand() % max_degree);
}
}
q_dof_handler.distribute_dofs(fe_q);
q_solution.reinit(q_dof_handler.n_dofs());
dgq_dof_handler.distribute_dofs(fe_dgq);
dgq_solution.reinit(dgq_dof_handler.n_dofs());
AffineConstraints<double> cm;
cm.close();
VectorTools::interpolate(mapping, q_dof_handler, function, q_solution);
VectorTools::interpolate(mapping, dgq_dof_handler, function, dgq_solution);
parallel::distributed::SolutionTransfer<dim, LinearAlgebra::distributed::Vector<double>, hp::DoFHandler<dim>> q_soltrans(q_dof_handler);
parallel::distributed::SolutionTransfer<dim, LinearAlgebra::distributed::Vector<double>, hp::DoFHandler<dim>> dgq_soltrans(dgq_dof_handler);
// test b): do some coarsening and
// refinement
counter = 0;
cell = tria.begin_active();
endc = tria.end();
for (; cell != endc; ++cell, ++counter)
{
if (counter > 120)
cell->set_coarsen_flag();
else if (Testing::rand() % 3 == 0)
cell->set_refine_flag();
else if (Testing::rand() % 3 == 3)
cell->set_coarsen_flag();
}
LinearAlgebra::distributed::Vector<double> q_old_solution = q_solution, dgq_old_solution = dgq_solution;
tria.prepare_coarsening_and_refinement();
q_soltrans.prepare_for_coarsening_and_refinement(q_old_solution);
dgq_soltrans.prepare_for_coarsening_and_refinement(dgq_old_solution);
tria.execute_coarsening_and_refinement();
counter = 0;
//{
// typename hp::DoFHandler<dim>::active_cell_iterator
// cell = q_dof_handler.begin_active(),
// celldg = dgq_dof_handler.begin_active(), endc = q_dof_handler.end();
// for (; cell != endc; ++cell, ++celldg, ++counter)
// {
// if (counter > 20 && counter < 90)
// cell->set_active_fe_index(0);
// else
// cell->set_active_fe_index(Testing::rand() % max_degree);
// if (counter > 20 && counter < 90)
// celldg->set_active_fe_index(0);
// else
// celldg->set_active_fe_index(Testing::rand() % max_degree);
// }
//}
q_dof_handler.distribute_dofs(fe_q);
dgq_dof_handler.distribute_dofs(fe_dgq);
q_solution.reinit(q_dof_handler.n_dofs());
dgq_solution.reinit(dgq_dof_handler.n_dofs());
q_soltrans.interpolate(q_solution);
dgq_soltrans.interpolate(dgq_solution);
// check correctness by comparing the values
// on points of QGauss of order 2.
MyFunction<dim> func;
{
double error = 0;
const hp::QCollection<dim> quad(QGauss<dim>(2));
hp::FEValues<dim> hp_fe_val(fe_q,
quad,
update_values | update_quadrature_points);
std::vector<double> vals(quad[0].size());
typename hp::DoFHandler<dim>::active_cell_iterator cell = q_dof_handler
.begin_active(),
endc =
q_dof_handler.end();
for (; cell != endc; ++cell)
{
hp_fe_val.reinit(cell, 0);
const FEValues<dim> &fe_val = hp_fe_val.get_present_fe_values();
fe_val.get_function_values(q_solution, vals);
for (unsigned int q = 0; q < fe_val.n_quadrature_points; ++q)
{
error +=
std::fabs(func.value(fe_val.quadrature_point(q), 0) - vals[q]);
}
}
deallog << "Error in interpolating hp FE_Q: " << error << std::endl;
}
{
double error = 0;
const hp::QCollection<dim> quad(QGauss<dim>(2));
hp::FEValues<dim> hp_fe_val(fe_dgq,
quad,
update_values | update_quadrature_points);
std::vector<double> vals(quad[0].size());
typename hp::DoFHandler<dim>::active_cell_iterator
celldg = dgq_dof_handler.begin_active(),
endc = dgq_dof_handler.end();
for (; celldg != endc; ++celldg)
{
hp_fe_val.reinit(celldg, 0);
const FEValues<dim> &fe_val = hp_fe_val.get_present_fe_values();
fe_val.get_function_values(dgq_solution, vals);
for (unsigned int q = 0; q < fe_val.n_quadrature_points; ++q)
{
error +=
std::fabs(func.value(fe_val.quadrature_point(q), 0) - vals[q]);
}
}
deallog << "Error in interpolating hp FE_DGQ: " << error << std::endl;
}
}
int
main(int argc, char *argv[])
{
#ifdef DEAL_II_WITH_MPI
Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
#else
(void)argc;
(void)argv;
#endif
initlog();
// deallog << " 1D solution transfer" << std::endl;
// transfer<1>(deallog.get_file_stream());
deallog << " 2D solution transfer" << std::endl;
transfer<2>(deallog.get_file_stream());
deallog << " 3D solution transfer" << std::endl;
transfer<3>(deallog.get_file_stream());
}
