assembly.h

Go to the documentation of this file.

/*
 Copyright (C) 2016 - 2024 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 doc/COPYING.  If not see
 <http://www.gnu.org/licenses/>.
 */

#ifndef _aspect_volume_of_fluid_assembly_h
#define _aspect_volume_of_fluid_assembly_h

#include <aspect/global.h>
#include <aspect/simulator_access.h>

#include <deal.II/fe/fe_values.h>

namespace aspect
{
  using namespace dealii;

  template <int dim>
  class Simulator;

  template <int dim>
  struct VolumeOfFluidField;

  namespace internal
  {
    namespace Assembly
    {
      namespace Scratch
      {
        template <int dim>
        struct VolumeOfFluidSystem
        {
          VolumeOfFluidSystem (const FiniteElement<dim> &finite_element,
                               const FiniteElement<dim> &volume_of_fluid_element,
                               const Mapping<dim>       &mapping,
                               const Quadrature<dim>    &quadrature,
                               const Quadrature<dim-1>  &face_quadrature);

          VolumeOfFluidSystem (const VolumeOfFluidSystem &scratch);

          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;

          FEValues<dim>          finite_element_values;
          FEValues<dim>          neighbor_finite_element_values;
          FEFaceValues<dim>      face_finite_element_values;
          FEFaceValues<dim>      neighbor_face_finite_element_values;
          FESubfaceValues<dim>   subface_finite_element_values;

          std::vector<types::global_dof_index>   local_dof_indices;

          // Field for exact cell volume (needed in some of the face flux calculations)
          double volume;

          std::vector<double>         phi_field;
          std::vector<double>         face_phi_field;

          std::vector<double>         old_field_values;
          /* Vector for interface normal in the unit cell */
          std::vector<Tensor<1,dim>> cell_i_n_values;
          /* "Distance" from cell center to interface as d value for the interface in the form @f$\vec{n}\cdot\vec{x}=d@f$ */
          std::vector<double>         cell_i_d_values;

          std::vector<Tensor<1,dim>> face_current_velocity_values;
          std::vector<Tensor<1,dim>> face_old_velocity_values;
          std::vector<Tensor<1,dim>> face_old_old_velocity_values;

          std::vector<double>         neighbor_old_values;
          /* Vector for interface normal in the unit cell */
          std::vector<Tensor<1,dim>> neighbor_i_n_values;
          /* "Distance" from cell center to interface as d value for the interface in the form @f$\vec{n}\cdot\vec{x}=d@f$ */
          std::vector<double>         neighbor_i_d_values;
        };
      }

      namespace CopyData
      {
        template <int dim>
        struct VolumeOfFluidSystem
        {
          VolumeOfFluidSystem(const FiniteElement<dim> &finite_element);
          VolumeOfFluidSystem(const VolumeOfFluidSystem &data);

          VolumeOfFluidSystem &operator=(const VolumeOfFluidSystem &) = default;

          FullMatrix<double>          local_matrix;
          Vector<double>              local_rhs;

          std::vector<Vector<double>> local_face_rhs;
          std::vector<FullMatrix<double>> local_face_matrices_ext_ext;

          std::vector<bool> face_contributions_mask;

          std::vector<types::global_dof_index>   local_dof_indices;

          std::vector<std::vector<types::global_dof_index>> neighbor_dof_indices;
        };
      }
    }
  }

  namespace Assemblers
  {

    template <int dim>
    class VolumeOfFluidAssembler : public SimulatorAccess<dim>
    {
      public:
        void local_assemble_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
                                                    const unsigned int calc_dir,
                                                    const bool update_from_old,
                                                    const typename DoFHandler<dim>::active_cell_iterator &cell,
                                                    internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
                                                    internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;

        void local_assemble_boundary_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
                                                                  const bool update_from_old,
                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
                                                                  const unsigned int face_no,
                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;

        void local_assemble_internal_face_volume_of_fluid_system (const VolumeOfFluidField<dim> &field,
                                                                  const bool update_from_old,
                                                                  const typename DoFHandler<dim>::active_cell_iterator &cell,
                                                                  const unsigned int face_no,
                                                                  internal::Assembly::Scratch::VolumeOfFluidSystem<dim> &scratch,
                                                                  internal::Assembly::CopyData::VolumeOfFluidSystem<dim> &data) const;

        void set_volume_fraction_threshold(const double value);
    };
  }
}


#endif