sample_point_parameters.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 SAMPLE_POINT_PARAMETERS_HEADER
#define SAMPLE_POINT_PARAMETERS_HEADER
 
 
// oomph-lib includes
#include "elements.h"
#include "mesh.h"
 
namespace oomph
{
  //=========================================================
  //=========================================================
  enum Sample_Point_Container_Type
  {
    UseRefineableBinArray = 1,
    UseNonRefineableBinArray = 2
#ifdef OOMPH_HAS_CGAL
    ,
    UseCGALSamplePointContainer = 3
#endif
  };
 
 
 
 
  // Forward references
  class RefineableBinArray;
  class NonRefineableBinArray;
 
 
 
 
  //=========================================================================
  //=========================================================================
  class SamplePointContainerParameters
  {
  public:
    friend class BinArrayParameters;
    friend class RefineableBinArrayParameters;
    friend class NonRefineableBinArrayParameters;
#ifdef OOMPH_HAS_CGAL
    friend class CGALSamplePointContainerParameters;
#endif
 
    SamplePointContainerParameters(const SamplePointContainerParameters& data) =
      delete;
 
    void operator=(const SamplePointContainerParameters&) = delete;
 
    virtual ~SamplePointContainerParameters() {}
 
    Mesh* mesh_pt() const
    {
      return Mesh_pt;
    }
 
    Vector<std::pair<double, double>>& min_and_max_coordinates()
    {
      return Min_and_max_coordinates;
    }
 
    Vector<std::pair<double, double>> min_and_max_coordinates() const
    {
      return Min_and_max_coordinates;
    }
 
    unsigned nsample_points_generated_per_element() const
    {
      return Nsample_points_generated_per_element;
    }
 
    unsigned& nsample_points_generated_per_element()
    {
      return Nsample_points_generated_per_element;
    }
 
    bool use_eulerian_coordinates_during_setup() const
    {
      return Use_eulerian_coordinates_during_setup;
    }
 
    void enable_use_eulerian_coordinates_during_setup()
    {
      Use_eulerian_coordinates_during_setup = true;
    }
 
    void disable_use_eulerian_coordinates_during_setup()
    {
      Use_eulerian_coordinates_during_setup = false;
    }
 
    bool ignore_halo_elements_during_locate_zeta_search() const
    {
      return Ignore_halo_elements_during_locate_zeta_search;
    }
 
    void enable_ignore_halo_elements_during_locate_zeta_search()
    {
      Ignore_halo_elements_during_locate_zeta_search = true;
    }
 
    void disable_ignore_halo_elements_during_locate_zeta_search()
    {
      Ignore_halo_elements_during_locate_zeta_search = false;
    }
 
    static unsigned Default_nsample_points_generated_per_element;
 
  protected:
    Mesh* Mesh_pt;
 
    Vector<std::pair<double, double>> Min_and_max_coordinates;
 
    unsigned Nsample_points_generated_per_element;
 
    bool Use_eulerian_coordinates_during_setup;
 
    bool Ignore_halo_elements_during_locate_zeta_search;
 
 
  private:
    SamplePointContainerParameters(Mesh* mesh_pt)
      : Mesh_pt(mesh_pt),
        Nsample_points_generated_per_element(
          Default_nsample_points_generated_per_element),
        Use_eulerian_coordinates_during_setup(false),
        Ignore_halo_elements_during_locate_zeta_search(false)
    {
    }
 
    SamplePointContainerParameters()
    {
      // Throw the error
      throw OomphLibError("Broken default constructor. Don't call this!",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
  };
 
 
 
#ifdef OOMPH_HAS_CGAL
 
  //=========================================================================
  //=========================================================================
  class CGALSamplePointContainerParameters
    : public virtual SamplePointContainerParameters
  {
  public:
    CGALSamplePointContainerParameters(Mesh* mesh_pt)
      : SamplePointContainerParameters(mesh_pt)
    {
    }
 
 
    CGALSamplePointContainerParameters(
      const CGALSamplePointContainerParameters& data) = delete;
 
    void operator=(const CGALSamplePointContainerParameters&) = delete;
  };
 
#endif
 
 
 
  //=========================================================================
  //=========================================================================
  class BinArrayParameters : public virtual SamplePointContainerParameters
  {
  public:
    friend class RefineableBinArrayParameters;
    friend class NonRefineableBinArrayParameters;
 
    BinArrayParameters(const BinArrayParameters& data) = delete;
 
    void operator=(const BinArrayParameters&) = delete;
 
    virtual ~BinArrayParameters() {}
 
    Vector<unsigned>& dimensions_of_bin_array()
    {
      return Dimensions_of_bin_array;
    }
 
    Vector<unsigned> dimensions_of_bin_array() const
    {
      return Dimensions_of_bin_array;
    }
 
  protected:
    Vector<unsigned> Dimensions_of_bin_array;
 
  private:
    BinArrayParameters(Mesh* mesh_pt) : SamplePointContainerParameters(mesh_pt)
    {
    }
 
    BinArrayParameters()
    {
      // Throw the error
      throw OomphLibError("Broken default constructor. Don't call this!",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
  };
 
 
 
 
  //=========================================================================
  //=========================================================================
  class RefineableBinArrayParameters : public virtual BinArrayParameters
  {
  public:
    RefineableBinArrayParameters(Mesh* mesh_pt)
      : SamplePointContainerParameters(mesh_pt),
        BinArrayParameters(mesh_pt),
        Bin_array_is_recursive(true),
        Depth(0),
        Max_depth(Default_max_depth),
        Max_number_of_sample_point_per_bin(
          Default_max_number_of_sample_point_per_bin),
        Root_bin_array_pt(0)
    {
    }
 
    RefineableBinArrayParameters(const RefineableBinArrayParameters& data) =
      delete;
 
    void operator=(const RefineableBinArrayParameters&) = delete;
 
    virtual ~RefineableBinArrayParameters() {}
 
 
    bool bin_array_is_recursive() const
    {
      return Bin_array_is_recursive;
    }
 
    void enable_bin_array_is_recursive()
    {
      Bin_array_is_recursive = true;
    }
 
    void disable_bin_array_is_recursive()
    {
      Bin_array_is_recursive = false;
    }
 
    unsigned& depth()
    {
      return Depth;
    }
 
    unsigned depth() const
    {
      return Depth;
    }
 
    unsigned& max_depth()
    {
      return Max_depth;
    }
 
    unsigned max_depth() const
    {
      return Max_depth;
    }
 
    unsigned& max_number_of_sample_point_per_bin()
    {
      return Max_number_of_sample_point_per_bin;
    }
 
    unsigned max_number_of_sample_point_per_bin() const
    {
      return Max_number_of_sample_point_per_bin;
    }
 
    RefineableBinArray*& root_bin_array_pt()
    {
      return Root_bin_array_pt;
    }
 
    RefineableBinArray* root_bin_array_pt() const
    {
      return Root_bin_array_pt;
    }
 
    static unsigned Default_max_depth;
 
    static unsigned Default_max_number_of_sample_point_per_bin;
 
  private:
    bool Bin_array_is_recursive;
 
    unsigned Depth;
 
    unsigned Max_depth;
 
    unsigned Max_number_of_sample_point_per_bin;
 
    RefineableBinArray* Root_bin_array_pt;
  };
 
 
 
 
  //=========================================================================
  //=========================================================================
  class NonRefineableBinArrayParameters : public virtual BinArrayParameters
  {
  public:
    NonRefineableBinArrayParameters(Mesh* mesh_pt)
      : SamplePointContainerParameters(mesh_pt),
        BinArrayParameters(mesh_pt),
        Nspiral_chunk(Default_nspiral_chunk)
    {
    }
 
    NonRefineableBinArrayParameters(
      const NonRefineableBinArrayParameters& data) = delete;
 
    void operator=(const NonRefineableBinArrayParameters&) = delete;
 
    virtual ~NonRefineableBinArrayParameters() {}
 
    unsigned nspiral_chunk() const
    {
      return Nspiral_chunk;
    }
    unsigned& nspiral_chunk()
    {
      return Nspiral_chunk;
    }
 
    static unsigned Default_nspiral_chunk;
 
  private:
    unsigned Nspiral_chunk;
  };
 
} // namespace oomph
 
#endif