composition_manifold.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2016 - 2020 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_composition_manifold_h
#define dealii_composition_manifold_h
 
 
/*----------------------------   composition_manifold.h     ------------*/
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/derivative_form.h>
#include <deal.II/base/enable_observer_pointer.h>
#include <deal.II/base/point.h>
#include <deal.II/base/quadrature_lib.h>
 
#include <deal.II/grid/manifold.h>
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
#include <deal.II/grid/tria_iterator.h>
 
#include <memory>
 
DEAL_II_NAMESPACE_OPEN
 
template <int dim,
          int spacedim         = dim,
          int chartdim         = dim,
          int intermediate_dim = dim,
          int dim1             = dim,
          int dim2             = dim>
class CompositionManifold : public ChartManifold<dim, spacedim, chartdim>
{
public:
  CompositionManifold(const ChartManifold<dim1, intermediate_dim, chartdim> &F,
                      const ChartManifold<dim2, spacedim, intermediate_dim> &G);
 
  virtual std::unique_ptr<Manifold<dim, spacedim>>
  clone() const override;
 
  virtual Point<chartdim>
  pull_back(const Point<spacedim> &space_point) const;
 
 
  virtual Point<spacedim>
  push_forward(const Point<chartdim> &chart_point) const;
 
  virtual DerivativeForm<1, chartdim, spacedim>
  push_forward_gradient(const Point<chartdim> &chart_point) const;
 
private:
  ObserverPointer<
    const ChartManifold<dim1, intermediate_dim, chartdim>,
    CompositionManifold<dim, spacedim, chartdim, dim1, dim2, intermediate_dim>>
    F;
 
 
  ObserverPointer<
    const ChartManifold<dim2, spacedim, intermediate_dim>,
    CompositionManifold<dim, spacedim, chartdim, dim1, dim2, intermediate_dim>>
    G;
};
 
 
/*------------------Template Implementations------------------------*/
 
template <int dim,
          int spacedim,
          int chartdim,
          int intermediate_dim,
          int dim1,
          int dim2>
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
  CompositionManifold(const ChartManifold<dim1, intermediate_dim, chartdim> &F,
                      const ChartManifold<dim2, spacedim, intermediate_dim> &G)
  : ChartManifold<dim, spacedim, chartdim>(F.get_periodicity())
  , F(&F)
  , G(&G)
{
  // We don't know what to do with a periodicity in the second manifold, so
  // throw an assertion if the second manifold is periodic
  Assert(G.get_periodicity().norm() == 0.0,
         ExcMessage("The second manifold cannot be periodic."));
}
 
 
template <int dim,
          int spacedim,
          int chartdim,
          int intermediate_dim,
          int dim1,
          int dim2>
std::unique_ptr<Manifold<dim, spacedim>>
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
  clone() const
{
  return std::make_unique<
    CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>>(
    *F, *G);
}
 
 
template <int dim,
          int spacedim,
          int chartdim,
          int intermediate_dim,
          int dim1,
          int dim2>
Point<chartdim>
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
  pull_back(const Point<spacedim> &space_point) const
{
  return F->pull_back(G->pull_back(space_point));
}
 
 
 
template <int dim,
          int spacedim,
          int chartdim,
          int intermediate_dim,
          int dim1,
          int dim2>
Point<spacedim>
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
  push_forward(const Point<chartdim> &chart_point) const
{
  return G->push_forward(F->push_forward(chart_point));
}
 
 
 
template <int dim,
          int spacedim,
          int chartdim,
          int intermediate_dim,
          int dim1,
          int dim2>
DerivativeForm<1, chartdim, spacedim>
CompositionManifold<dim, spacedim, chartdim, intermediate_dim, dim1, dim2>::
  push_forward_gradient(const Point<chartdim> &chart_point) const
{
  DerivativeForm<1, chartdim, intermediate_dim> DF =
    F->push_forward_gradient(chart_point);
 
  DerivativeForm<1, intermediate_dim, spacedim> DG =
    G->push_forward_gradient(F->push_forward(chart_point));
 
  DerivativeForm<1, chartdim, spacedim> DF_DG;
 
  for (unsigned int d = 0; d < spacedim; ++d)
    for (unsigned int c = 0; c < chartdim; ++c)
      for (unsigned int s = 0; s < intermediate_dim; ++s)
        DF_DG[d][c] += DG[d][s] * DF[s][c];
 
  return DF_DG;
}
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif