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
{
  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