parallel_unstructured_interface.h

Go to the documentation of this file.

/*
  Copyright (C) 2011 - 2026 by the authors of the ASPECT code.

  This file is part of ASPECT.

  ASPECT is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.

  ASPECT is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with ASPECT; see the file LICENSE.  If not see
  <http://www.gnu.org/licenses/>.
*/


#ifndef _aspect_mesh_deformation_parallel_unstructured_interface_h
#define _aspect_mesh_deformation_parallel_unstructured_interface_h

#include <aspect/mesh_deformation/interface.h>


namespace aspect
{
  namespace MeshDeformation
  {
    template <int dim>
    class ParallelUnstructuredInterface : public Interface<dim>, public SimulatorAccess<dim>
    {
      public:
        virtual
        void
        compute_velocity_constraints_on_boundary(const DoFHandler<dim> &mesh_deformation_dof_handler,
                                                 AffineConstraints<double> &mesh_velocity_constraints,
                                                 const std::set<types::boundary_id> &boundary_ids) const override;

        virtual
        std::vector<Tensor<1,dim>>
        compute_updated_velocities_at_points (const std::vector<std::vector<double>> &current_solution_at_points) const = 0;


      protected:
        // Helper functions to be used in derived classes:

        void
        set_evaluation_points (const std::vector<Point<dim>> &evaluation_points);

        std::vector<std::vector<double>>
        evaluate_aspect_solution_at_points () const;

        LinearAlgebra::Vector
        interpolate_external_velocities_to_surface_support_points (const std::vector<Tensor<1,dim>> &velocities) const;

        std::vector<Point<dim>> evaluation_points;

        std::unique_ptr<Utilities::MPI::RemotePointEvaluation<dim, dim>> remote_point_evaluator;

        struct DofToEvalPointData
        {
          types::global_dof_index dof_index;
          unsigned int            evaluation_point_rank;
          unsigned int            evaluation_point_index;
          unsigned int            component;
          double                  squared_distance;

          template <class Archive>
          void
          serialize(Archive &ar, const unsigned int /*version*/)
          {
            ar &dof_index;
            ar &evaluation_point_rank;
            ar &evaluation_point_index;
            ar &component;
            ar &squared_distance;
          }
        };

        std::vector<DofToEvalPointData> map_dof_to_eval_point;
    };
  }
}

#endif