rectangle_with_moving_cylinder_mesh.template.h

Go to the documentation of this file.

// LIC// ====================================================================
// LIC// This file forms part of oomph-lib, the object-oriented,
// LIC// multi-physics finite-element library, available
// LIC// at http://www.oomph-lib.org.
// LIC//
// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
// LIC//
// LIC// This library is free software; you can redistribute it and/or
// LIC// modify it under the terms of the GNU Lesser General Public
// LIC// License as published by the Free Software Foundation; either
// LIC// version 2.1 of the License, or (at your option) any later version.
// LIC//
// LIC// This library is distributed in the hope that it will be useful,
// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// LIC// Lesser General Public License for more details.
// LIC//
// LIC// You should have received a copy of the GNU Lesser General Public
// LIC// License along with this library; if not, write to the Free Software
// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// LIC// 02110-1301  USA.
// LIC//
// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
// LIC//
// LIC//====================================================================
// Header file for SpaceTimeNavierStokesMixedOrder elements
#ifndef OOMPH_RECTANGLE_WITH_MOVING_CYLINDER_MESH_HEADER
#define OOMPH_RECTANGLE_WITH_MOVING_CYLINDER_MESH_HEADER
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
#include "../generic/domain.h"
#include "../generic/geom_objects.h"
#include "../generic/refineable_quad_mesh.h"
 
// Refineable quad mesh headers
#include "rectangular_quadmesh.template.h"
 
// Namespace extension
namespace oomph
{
  //=============================================================================
  //=============================================================================
  class RectangleWithHoleAndAnnularRegionDomain : public Domain
  {
  public:
    RectangleWithHoleAndAnnularRegionDomain(GeomObject* cylinder_pt,
                                            const double& annular_region_radius,
                                            const double& length)
      : Cylinder_pt(cylinder_pt), Annular_region_radius(annular_region_radius)
    {
      // Vertices of rectangle
      Lower_left.resize(2);
      Lower_left[0] = -0.5 * length;
      Lower_left[1] = -0.5 * length;
 
      Upper_left.resize(2);
      Upper_left[0] = -0.5 * length;
      Upper_left[1] = 0.5 * length;
 
      Lower_right.resize(2);
      Lower_right[0] = 0.5 * length;
      Lower_right[1] = -0.5 * length;
 
      Upper_right.resize(2);
      Upper_right[0] = 0.5 * length;
      Upper_right[1] = 0.5 * length;
 
      // Coordinates of points where the "radial" lines from central
      // cylinder meet the upper and lower boundaries
      Lower_mid_left.resize(2);
      Lower_mid_left[0] = -0.5 * length;
      Lower_mid_left[1] = -0.5 * length;
 
      Upper_mid_left.resize(2);
      Upper_mid_left[0] = -0.5 * length;
      Upper_mid_left[1] = 0.5 * length;
 
      Lower_mid_right.resize(2);
      Lower_mid_right[0] = 0.5 * length;
      Lower_mid_right[1] = -0.5 * length;
 
      Upper_mid_right.resize(2);
      Upper_mid_right[0] = 0.5 * length;
      Upper_mid_right[1] = 0.5 * length;
 
      // The number of macro elements
      unsigned n_macro_element = 8;
 
      // There are four macro elements
      Macro_element_pt.resize(n_macro_element);
 
      // Build the 2D macro elements
      for (unsigned i = 0; i < n_macro_element; i++)
      {
        // Create the i-th macro element
        Macro_element_pt[i] = new QMacroElement<2>(this, i);
      }
    } // End of RectangleWithHoleAndAnnularRegionDomain
 
 
    ~RectangleWithHoleAndAnnularRegionDomain() {}
 
 
    void project_point_on_cylinder_to_annular_boundary(const unsigned& time,
                                                       const Vector<double>& xi,
                                                       Vector<double>& r);
 
    void project_point_on_cylinder_to_annular_boundary(const double& time,
                                                       const Vector<double>& xi,
                                                       Vector<double>& r);
 
 
    void linear_interpolate(const Vector<double>& left,
                            const Vector<double>& right,
                            const double& s,
                            Vector<double>& f)
    {
      // Loop over the coordinates
      for (unsigned i = 0; i < 2; i++)
      {
        // Get the linear interpolation of the two points
        f[i] = left[i] + (right[i] - left[i]) * 0.5 * (s + 1.0);
      }
    } // End of linear_interpolate
 
 
    void macro_element_boundary(const double& time,
                                const unsigned& m,
                                const unsigned& direction,
                                const Vector<double>& s,
                                Vector<double>& f);
 
    void macro_element_boundary(const unsigned& time,
                                const unsigned& m,
                                const unsigned& direction,
                                const Vector<double>& s,
                                Vector<double>& f);
 
  private:
    Vector<double> Lower_left;
 
    Vector<double> Lower_right;
 
    Vector<double> Lower_mid_left;
 
    Vector<double> Lower_mid_right;
 
    Vector<double> Upper_left;
 
    Vector<double> Upper_right;
 
    Vector<double> Upper_mid_left;
 
    Vector<double> Upper_mid_right;
 
    GeomObject* Cylinder_pt;
 
    double Annular_region_radius;
  };
 
 
  //=============================================================================
  //=============================================================================
  template<class ELEMENT>
  class RectangleWithHoleAndAnnularRegionMesh : public virtual Mesh
  {
  public:
    RectangleWithHoleAndAnnularRegionMesh(
      GeomObject* cylinder_pt,
      const double& annular_region_radius,
      const double& length,
      TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper);
 
    ~RectangleWithHoleAndAnnularRegionMesh()
    {
      // If it's a non-null pointer (don't know why it shouldn't be but
      // still...)
      if (Domain_pt != 0)
      {
        // Delete the domain pointer
        delete Domain_pt;
 
        // Make it a null pointer
        Domain_pt = 0;
      }
    } // End of ~RectangleWithHoleAndAnnularRegionMesh
 
    RectangleWithHoleAndAnnularRegionDomain* domain_pt()
    {
      // Return a pointer to the Domain object defining the domain
      return Domain_pt;
    }
 
  protected:
    RectangleWithHoleAndAnnularRegionDomain* Domain_pt;
  };
 
 
  //=============================================================================
  //=============================================================================
  template<class ELEMENT>
  class RefineableRectangleWithHoleAndAnnularRegionMesh
    : public RectangleWithHoleAndAnnularRegionMesh<ELEMENT>,
      public RefineableQuadMesh<ELEMENT>
  {
  public:
    RefineableRectangleWithHoleAndAnnularRegionMesh(
      GeomObject* cylinder_pt,
      const double& annular_region_radius,
      const double& length,
      TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper)
      : RectangleWithHoleAndAnnularRegionMesh<ELEMENT>(
          cylinder_pt, annular_region_radius, length, time_stepper_pt)
    {
      // Nodal positions etc. were created in constructor for
      // Cylinder...<...>. Need to set up adaptive information.
 
      // Get the size of the container
      unsigned n_macro_element = this->Domain_pt->nmacro_element();
 
      // Loop over all elements and set macro element pointer
      for (unsigned e = 0; e < n_macro_element; e++)
      {
        dynamic_cast<ELEMENT*>(this->element_pt(e))
          ->set_macro_elem_pt(this->Domain_pt->macro_element_pt(e));
      }
 
      // Setup boundary element lookup schemes
      this->setup_boundary_element_info();
 
      // Setup quadtree forest for mesh refinement
      this->setup_quadtree_forest();
    } // End of RefineableRectangleWithHoleAndAnnularRegionMesh
 
    virtual ~RefineableRectangleWithHoleAndAnnularRegionMesh() {}
  };
 
 
  //=============================================================================
  //=============================================================================
  template<class ELEMENT>
  class RefineableQuadMeshWithMovingCylinder
    : public virtual RefineableQuadMesh<ELEMENT>
  {
  public:
    RefineableQuadMeshWithMovingCylinder(
      GeomObject* cylinder_pt,
      const double& annular_region_radius,
      const double& length_of_central_box,
      const double& x_left,
      const double& x_right,
      const double& height,
      TimeStepper* time_stepper_pt = &Mesh::Default_TimeStepper);
 
    ~RefineableQuadMeshWithMovingCylinder()
    {
      // Delete the central mesh
      delete Central_mesh_pt;
 
      // Make it a null pointer
      Central_mesh_pt = 0;
    } // End of ~RefineableQuadMeshWithMovingCylinder
 
  private:
    RefineableRectangleWithHoleAndAnnularRegionMesh<ELEMENT>* Central_mesh_pt;
 
    // Make the problem as coarse as possible
    bool Coarse_problem;
  };
} // End of namespace oomph
 
#endif