domain.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//====================================================================
#ifndef OOMPH_DOMAIN_HEADER
#define OOMPH_DOMAIN_HEADER
 
 
// Config header generated by autoconfig
#ifdef HAVE_CONFIG_H
#include <oomph-lib-config.h>
#endif
 
// oomph-lib headers
#include "macro_element.h"
 
namespace oomph
{
  class MacroElement;
  class GeomObject;
 
  class GeomReference;
 
 
  //=================================================================
  //=================================================================
  class Domain
  {
  public:
    Domain()
    {
      // Make sure all containers are empty (a bit paranoid, I know...)
      Macro_element_pt.resize(0);
    }
 
    Domain(const Domain&) = delete;
 
    void operator=(const Domain&) = delete;
 
    virtual ~Domain()
    {
      // How many macro elements are there?
      unsigned n_macro_element = Macro_element_pt.size();
 
      // Loop over the macro elements
      for (unsigned i = 0; i < n_macro_element; i++)
      {
        // They might have already deleted (some or all of) the macro elements
        // so skip them if they've already been made null pointers
        if (Macro_element_pt[i] != 0)
        {
          // Delete the i-th macro element
          delete Macro_element_pt[i];
 
          // Make it a null pointer
          Macro_element_pt[i] = 0;
        }
      } // for (unsigned i=0;i<n_macro_element;i++)
 
      // Now clear the storage. NOTE: We can't just call this function
      // as this would only delete the pointers to the macro elements,
      // not the macro elements themselves!
      Macro_element_pt.clear();
 
    } // End of ~Domain
 
 
    MacroElement* macro_element_pt(const unsigned& i)
    {
      return Macro_element_pt[i];
    }
 
 
    unsigned nmacro_element()
    {
      return Macro_element_pt.size();
    }
 
    void output(const std::string& filename, const unsigned& nplot)
    {
      std::ofstream outfile;
      outfile.open(filename.c_str());
      output(outfile, nplot);
      outfile.close();
    }
 
    void output(std::ostream& outfile, const unsigned& nplot)
    {
      unsigned nmacro = Macro_element_pt.size();
      for (unsigned i_macro = 0; i_macro < nmacro; i_macro++)
      {
        Macro_element_pt[i_macro]->output(outfile, nplot);
      }
    }
 
 
    virtual void macro_element_boundary(const unsigned& t,
                                        const unsigned& i_macro,
                                        const unsigned& i_direct,
                                        const Vector<double>& s,
                                        Vector<double>& f) = 0;
 
 
    virtual void macro_element_boundary(const double& t,
                                        const unsigned& i_macro,
                                        const unsigned& i_direct,
                                        const Vector<double>& s,
                                        Vector<double>& f)
    {
      // Throw an error
      throw OomphLibError("Domain::macro_element_boundary() is broken virtual.",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    } // End of macro_element_boundary
 
 
    void macro_element_boundary(const unsigned& i_macro,
                                const unsigned& i_direct,
                                const Vector<double>& s,
                                Vector<double>& f)
    {
      // Call unsteady version for current time
      unsigned t = 0;
      macro_element_boundary(t, i_macro, i_direct, s, f);
    }
 
 
    void output_macro_element_boundaries(const std::string& filename,
                                         const unsigned& nplot)
    {
      std::ofstream outfile;
      outfile.open(filename.c_str());
      output_macro_element_boundaries(outfile, nplot);
      outfile.close();
    }
 
    void output_macro_element_boundaries(std::ostream& outfile,
                                         const unsigned& nplot)
    {
      // Loop over macro elements
      unsigned nmacro = nmacro_element();
      for (unsigned i = 0; i < nmacro; i++)
      {
        macro_element_pt(i)->output_macro_element_boundaries(outfile, nplot);
      }
    }
 
 
    virtual void dmacro_element_boundary(const unsigned& t,
                                         const unsigned& i_macro,
                                         const unsigned& i_direct,
                                         const Vector<double>& s,
                                         Vector<double>& f)
    {
      throw OomphLibError(
        "Domain::dmacro_element_boundary() is broken virtual.",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
 
    virtual void dmacro_element_boundary(const double& t,
                                         const unsigned& i_macro,
                                         const unsigned& i_direct,
                                         const Vector<double>& s,
                                         Vector<double>& f)
    {
      throw OomphLibError(
        "Domain::dmacro_element_boundary() is broken virtual.",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
 
    void dmacro_element_boundary(const unsigned& i_macro,
                                 const unsigned& i_direct,
                                 const Vector<double>& s,
                                 Vector<double>& f)
    {
      // Call unsteady version for current time
      unsigned t = 0;
      dmacro_element_boundary(t, i_macro, i_direct, s, f);
    }
 
 
    virtual void d2macro_element_boundary(const unsigned& t,
                                          const unsigned& i_macro,
                                          const unsigned& i_direct,
                                          const Vector<double>& s,
                                          Vector<double>& f)
    {
      throw OomphLibError(
        "Domain::d2macro_element_boundary() is broken virtual.",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    virtual void d2macro_element_boundary(const double& t,
                                          const unsigned& i_macro,
                                          const unsigned& i_direct,
                                          const Vector<double>& s,
                                          Vector<double>& f)
    {
      throw OomphLibError(
        "Domain::d2macro_element_boundary() is broken virtual.",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }
 
    void d2macro_element_boundary(const unsigned& i_macro,
                                  const unsigned& i_direct,
                                  const Vector<double>& s,
                                  Vector<double>& f)
    {
      // Call unsteady version for current time
      unsigned t = 0;
      d2macro_element_boundary(t, i_macro, i_direct, s, f);
    }
 
 
  protected:
    Vector<MacroElement*> Macro_element_pt;
  };
 
 
  // Warped cube domain
 
 
  //=================================================================
  //=================================================================
  class WarpedCubeDomain : public Domain
  {
  public:
    WarpedCubeDomain()
    {
      // Resize
      Macro_element_pt.resize(1);
 
      // Create macro element
      Macro_element_pt[0] = new QMacroElement<3>(this, 0);
    }
 
    WarpedCubeDomain(const WarpedCubeDomain&) = delete;
 
    void operator=(const WarpedCubeDomain&) = delete;
 
    ~WarpedCubeDomain() {}
 
 
    void warp_it(Vector<double>& f);
 
 
    void macro_element_boundary(const unsigned& t,
                                const unsigned& i_macro,
                                const unsigned& i_direct,
                                const Vector<double>& s,
                                Vector<double>& f);
 
 
  private:
    void r_L(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
 
    void r_R(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
 
 
    void r_D(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
 
 
    void r_U(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
 
 
    void r_B(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
 
 
    void r_F(const unsigned& t, const Vector<double>& zeta, Vector<double>& f);
  };
 
 
} // namespace oomph
 
#endif