RefineableBin Class Reference

#include <sample_point_container.h>

Public Member Functions
	RefineableBin (RefineableBinArray *bin_array_pt, const unsigned &bin_index_in_bin_array)
	RefineableBin (const RefineableBin &data)=delete
	Broken copy constructor. More...
void	operator= (const RefineableBin &)=delete
	Broken assignment operator. More...
	~RefineableBin ()
	Destructor. More...
unsigned	total_number_of_sample_points_computed_recursively () const
	Compute total number of sample points recursively. More...
void	add_sample_point (SamplePoint *new_sample_point_pt, const Vector< double > &zeta_coordinates)
	Add a new sample point to RefineableBin. More...
void	locate_zeta (const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)
void	output (std::ofstream &outfile, const bool &don_t_recurse=false)
	Output bin; x,[y,[z]],n_sample_points. More...
void	output_bins (std::ofstream &outfile)
	Output bin vertices (allowing display of bins as zones). More...
void	output_bin_vertices (std::ofstream &outfile)
	Output bin vertices (allowing display of bins as zones). More...
unsigned	nsample_points_in_bin ()
	Number of sample points stored in bin. More...

Protected Member Functions
void	make_sub_bin_array (const Vector< std::pair< double, double >> &min_and_max_coordinates)
void	get_bin_boundaries (Vector< std::pair< double, double >> &min_and_max_coordinates)

Protected Attributes
Vector< SamplePoint * > *	Sample_point_pt
RefineableBinArray *	Sub_bin_array_pt
	Pointer to a possible sub-BinArray. Null by default. More...
RefineableBinArray *	Bin_array_pt
	Pointer to the bin array which "owns" this RefineableBin. More...
unsigned	Bin_index_in_bin_array
	Index of bin in its bin array. More...

Detailed Description

RefineableBin class. Contains sample points and is embedded in a RefineableBinArray. May itself be represented by a RefineableBinArray to make it recursive.

Constructor & Destructor Documentation

RefineableBin() [1/2]

RefineableBin::RefineableBin ( RefineableBinArray *  bin_array_pt, const unsigned &  bin_index_in_bin_array  )

inline

Constructor. Pass pointer to bin array that contains this bin and the index of the newly created bin in that RefineableBinArray

    : Sample_point_pt(0),
      Sub_bin_array_pt(0),
      Bin_array_pt(bin_array_pt),
      Bin_index_in_bin_array(bin_index_in_bin_array)
  {
  }

RefineableBin() [2/2]

RefineableBin::RefineableBin ( const RefineableBin &  data )

delete

Broken copy constructor.

~RefineableBin()

RefineableBin::~RefineableBin

(

)

Destructor.

/////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

  {
    if (Sub_bin_array_pt != 0)
    {
      delete Sub_bin_array_pt;
    }
    Sub_bin_array_pt = 0;
 
    if (Sample_point_pt != 0)
    {
      unsigned n = Sample_point_pt->size();
      for (unsigned i = 0; i < n; i++)
      {
        delete (*Sample_point_pt)[i];
      }
      delete Sample_point_pt;
    }
  }

References i, and n.

Member Function Documentation

add_sample_point()

void RefineableBin::add_sample_point	(	SamplePoint *	new_sample_point_pt,
		const Vector< double > &	zeta_coordinates
	)

Add a new sample point to RefineableBin.

Add a SamplePoint* to a RefineableBin object.

  {
    // If the bin is a "leaf" (ie no sub bin array)
    if (Sub_bin_array_pt == 0)
    {
      // if there is no Sample_point_pt create it
      if (Sample_point_pt == 0)
      {
        Sample_point_pt = new Vector<SamplePoint*>;
      }
      this->Sample_point_pt->push_back(new_sample_point_pt);
 
      // If we are recursive (ie not at the maximum depth or not
      // in fill bin by diffusion configuration) and if the number
      // of elements there are in the RefineableBin is bigger than the maximum
      // one
      if ((Bin_array_pt->bin_array_is_recursive()) &&
          (Sample_point_pt->size() >
           Bin_array_pt->max_number_of_sample_point_per_bin()) &&
          (Bin_array_pt->depth() < Bin_array_pt->max_depth()))
      {
        // Get min and max coordinates of current bin...
        Vector<std::pair<double, double>> min_and_max_coordinates(
          Bin_array_pt->ndim_zeta());
        get_bin_boundaries(min_and_max_coordinates);
 
        // ...and use them as the boundaries for new sub-bin-array
        // (this transfers all the new points into the new sub-bin-array
        this->make_sub_bin_array(min_and_max_coordinates);
      }
    }
    else // if the bin has a sub bin array
    {
      // we call the corresponding method of the sub bin array
      this->Sub_bin_array_pt->add_sample_point(new_sample_point_pt,
                                               zeta_coordinates);
    }
  }

get_bin_boundaries()

void RefineableBin::get_bin_boundaries ( Vector< std::pair< double, double >> &  min_and_max_coordinates )

protected

Boundaries of bin in each coordinate direction. *.first = min; *.second = max

Boundaries of bin in each coordinate direction. *.first = min; *.second = max.

  {
    unsigned n_bin = Bin_index_in_bin_array;
 
    // temporary storage for the eulerian dim
    unsigned current_dim = Bin_array_pt->ndim_zeta();
    min_and_max_coordinates.resize(current_dim);
    for (unsigned u = 0; u < current_dim; u++)
    {
      // The number of bins there are according to the u-th dimension
      double nbin_in_dir = n_bin % Bin_array_pt->dimension_of_bin_array(u);
      n_bin /= Bin_array_pt->dimension_of_bin_array(u);
 
      // The range between the maximum and minimum u-th coordinates of a bin
      double range = (Bin_array_pt->min_and_max_coordinates(u).second -
                      Bin_array_pt->min_and_max_coordinates(u).first) /
                     double(Bin_array_pt->dimension_of_bin_array(u));
 
      // Now updating the minimum and maximum u-th coordinates for this bin.
      min_and_max_coordinates[u].first =
        Bin_array_pt->min_and_max_coordinates(u).first + nbin_in_dir * range;
      min_and_max_coordinates[u].second =
        min_and_max_coordinates[u].first + range;
    }
  }

locate_zeta()

void RefineableBin::locate_zeta	(	const Vector< double > &	zeta,
		GeomObject *&	sub_geom_object_pt,
		Vector< double > &	s
	)

Find sub-GeomObject (finite element) and the local coordinate s within it that contains point with global coordinate zeta. sub_geom_object_pt=0 if point can't be found.

  {
    // Haven't found zeta yet!
    sub_geom_object_pt = 0;
 
    // Descend?
    if (Sub_bin_array_pt != 0)
    {
      Sub_bin_array_pt->locate_zeta(zeta, sub_geom_object_pt, s);
    }
    else
    {
      // Do we have to look into any sample points in this bin?
      // NOTE: There's some slight potential for overlap/duplication
      // because we always search through all the sample points in a bin
      // (unless we find the required point in which case we stop).
      bool do_it = true;
      if (
        Bin_array_pt->root_bin_array_pt()
          ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level() <
        Bin_array_pt->root_bin_array_pt()
          ->first_sample_point_to_actually_lookup_during_locate_zeta())
      {
        // oomph_info << "Not doing it (ref-bin) because counter less than
        // first" << std::endl;
        do_it = false;
      }
      if (
        Bin_array_pt->root_bin_array_pt()
          ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level() >
        Bin_array_pt->root_bin_array_pt()
          ->last_sample_point_to_actually_lookup_during_locate_zeta())
      {
        // oomph_info << "Not doing it (ref-bin) because counter more than last"
        // << std::endl;
        do_it = false;
      }
      double max_search_radius =
        Bin_array_pt->root_bin_array_pt()->max_search_radius();
      bool dont_do_it_because_of_radius = false;
      if (max_search_radius < DBL_MAX)
      {
        // Base "radius" of bin on centre of gravity
        unsigned n = zeta.size();
        double dist_squared = 0.0;
        double cog = 0.0;
        double aux = 0.0;
        Vector<std::pair<double, double>> min_and_max_coordinates(n);
        get_bin_boundaries(min_and_max_coordinates);
        for (unsigned i = 0; i < n; i++)
        {
          cog = 0.5 * (min_and_max_coordinates[i].first +
                       min_and_max_coordinates[i].second);
          aux = (cog - zeta[i]);
          dist_squared += aux * aux;
        }
        if (dist_squared > max_search_radius * max_search_radius)
        {
          do_it = false;
          dont_do_it_because_of_radius = true;
        }
      }
 
      if (!do_it)
      {
        if (!dont_do_it_because_of_radius)
        {
          // Skip all the sample points in this bin
          Bin_array_pt->root_bin_array_pt()
            ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level() +=
            Sample_point_pt->size();
        }
        return;
      }
 
 
      // Now search through (at most) all the sample points in this bin
      unsigned n_sample_point = Sample_point_pt->size();
      unsigned i = 0;
      while ((i < n_sample_point) && (sub_geom_object_pt == 0))
      {
        // Get the corresponding finite element
        FiniteElement* el_pt = Bin_array_pt->mesh_pt()->finite_element_pt(
          (*Sample_point_pt)[i]->element_index_in_mesh());
 
#ifdef OOMPH_HAS_MPI
        // We only look at the sample point if it isn't halo
        // if we are set up to ignore the halo elements
        if ((Bin_array_pt->ignore_halo_elements_during_locate_zeta_search()) &&
            (el_pt->is_halo()))
        {
          // Halo
        }
        else
        {
#endif
          // Provide initial guess for Newton search using local coordinate
          // of sample point
          bool use_equally_spaced_interior_sample_points =
            SamplePointContainer::Use_equally_spaced_interior_sample_points;
          unsigned j = (*Sample_point_pt)[i]->sample_point_index_in_element();
          el_pt->get_s_plot(
            j,
            Bin_array_pt->nsample_points_generated_per_element(),
            s,
            use_equally_spaced_interior_sample_points);
 
 
          // History of sample points visited
          if (BinArray::Visited_sample_points_file.is_open())
          {
            unsigned cached_dim_zeta = Bin_array_pt->ndim_zeta();
            Vector<double> zeta_sample(cached_dim_zeta);
            if (Bin_array_pt->use_eulerian_coordinates_during_setup())
            {
              el_pt->interpolated_x(s, zeta_sample);
            }
            else
            {
              el_pt->interpolated_zeta(s, zeta_sample);
            }
            double dist = 0.0;
            for (unsigned ii = 0; ii < cached_dim_zeta; ii++)
            {
              BinArray::Visited_sample_points_file << zeta_sample[ii] << " ";
              dist +=
                (zeta[ii] - zeta_sample[ii]) * (zeta[ii] - zeta_sample[ii]);
            }
            BinArray::Visited_sample_points_file
              << Bin_array_pt->root_bin_array_pt()
                   ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level()
              << " " << sqrt(dist) << std::endl;
          }
 
 
          // Bump counter
          Bin_array_pt->root_bin_array_pt()
            ->total_number_of_sample_points_visited_during_locate_zeta_from_top_level()++;
 
          bool use_coordinate_as_initial_guess = true;
          el_pt->locate_zeta(
            zeta, sub_geom_object_pt, s, use_coordinate_as_initial_guess);
 
          // Always fail? (Used for debugging, e.g. to trace out
          // spiral path)
          if (BinArray::Always_fail_elemental_locate_zeta)
          {
            sub_geom_object_pt = 0;
          }
 
#ifdef OOMPH_HAS_MPI
        }
#endif
        // Next one please
        i++;
      }
    }
  }

References SamplePointContainer::Always_fail_elemental_locate_zeta, i, j, n, s, sqrt(), SamplePointContainer::Use_equally_spaced_interior_sample_points, SamplePointContainer::Visited_sample_points_file, and Eigen::zeta().

make_sub_bin_array()

void RefineableBin::make_sub_bin_array ( const Vector< std::pair< double, double >> &  min_and_max_coordinates )

protected

Method for building a new subbin_array (called when the Bin size is greater than the Max_number_of_sample_point_per_bin (and the Bin is recursive). Pass in the extremal coordinates of the bin which is being subdivided. Redistributes all existing sample points to newly made sub-bin-array and empties its own storage. Pass Max./min. coordinates of new bin array for efficiency.

Function called for making a sub bin array in a given RefineableBin. Pass the vector of min and max coordinates of the NEW bin array.

  {
    // Setup parameters for sub-bin
    RefineableBinArrayParameters* ref_bin_array_parameters_pt =
      new RefineableBinArrayParameters(Bin_array_pt->mesh_pt());
 
    // Pass coordinates and dimensions
    ref_bin_array_parameters_pt->min_and_max_coordinates() =
      min_and_max_coordinates;
 
    ref_bin_array_parameters_pt->dimensions_of_bin_array() =
      Bin_array_pt->dimensions_of_bin_array();
 
    // Eulerian coordinates or zeta?
    if (Bin_array_pt->use_eulerian_coordinates_during_setup())
    {
      ref_bin_array_parameters_pt
        ->enable_use_eulerian_coordinates_during_setup();
    }
    else
    {
      ref_bin_array_parameters_pt
        ->disable_use_eulerian_coordinates_during_setup();
    }
 
 
#ifdef OOMPH_HAS_MPI
 
    // How do we handle halo elements?
    if (Bin_array_pt->ignore_halo_elements_during_locate_zeta_search())
    {
      ref_bin_array_parameters_pt
        ->enable_ignore_halo_elements_during_locate_zeta_search();
    }
    else
    {
      ref_bin_array_parameters_pt
        ->disable_ignore_halo_elements_during_locate_zeta_search();
    }
 
#endif
 
    // "Measure of" number of sample points per element
    ref_bin_array_parameters_pt->nsample_points_generated_per_element() =
      Bin_array_pt->nsample_points_generated_per_element();
 
 
    // Is it recursive?
    if (Bin_array_pt->bin_array_is_recursive())
    {
      ref_bin_array_parameters_pt->enable_bin_array_is_recursive();
    }
    else
    {
      ref_bin_array_parameters_pt->disable_bin_array_is_recursive();
    }
 
    // Depth
    ref_bin_array_parameters_pt->depth() = Bin_array_pt->depth() + 1;
 
    // Max. depth
    ref_bin_array_parameters_pt->max_depth() = Bin_array_pt->max_depth();
 
    // Max. number of sample points before it's subdivided
    ref_bin_array_parameters_pt->max_number_of_sample_point_per_bin() =
      Bin_array_pt->max_number_of_sample_point_per_bin();
 
    // Root bin array
    ref_bin_array_parameters_pt->root_bin_array_pt() =
      Bin_array_pt->root_bin_array_pt();
 
    // We first construct a new bin array, providing the right parameters
    BinArrayParameters* bin_array_parameters_pt = ref_bin_array_parameters_pt;
    Sub_bin_array_pt = new RefineableBinArray(bin_array_parameters_pt);
    delete ref_bin_array_parameters_pt;
 
    // Fill it
    Sub_bin_array_pt->fill_bin_array(*Sample_point_pt);
 
    // Now deleting Sample_point_pt, we no longer need it; note that
    // sample points themselves stay alive!
    delete Sample_point_pt;
    Sample_point_pt = 0;
  }

nsample_points_in_bin()

unsigned RefineableBin::nsample_points_in_bin ( )

inline

Number of sample points stored in bin.

  {
    if (Sample_point_pt == 0)
    {
      return 0;
    }
    else
    {
      return Sample_point_pt->size();
    }
  }

References Sample_point_pt.

operator=()

void RefineableBin::operator= ( const RefineableBin &  )

delete

Broken assignment operator.

output()

void RefineableBin::output	(	std::ofstream &	outfile,
		const bool &	don_t_recurse = false
	)

Output bin; x,[y,[z]],n_sample_points.

  {
    // Recurse?
    if ((Sub_bin_array_pt != 0) && (!don_t_recurse))
    {
      Sub_bin_array_pt->output_bins(outfile);
    }
    else
    {
      unsigned n_lagr = Bin_array_pt->ndim_zeta();
      Vector<std::pair<double, double>> min_and_max_coordinates(n_lagr);
      get_bin_boundaries(min_and_max_coordinates);
 
      // How many sample points do we have in this bin?
      unsigned n_sample_points = 0;
      if (Sample_point_pt != 0)
      {
        n_sample_points = Sample_point_pt->size();
      }
 
      switch (n_lagr)
      {
        case 1:
          outfile << "ZONE I=2\n"
                  << min_and_max_coordinates[0].first << " " << n_sample_points
                  << std::endl
                  << min_and_max_coordinates[0].second << " " << n_sample_points
                  << std::endl;
          break;
 
        case 2:
 
          outfile << "ZONE I=2, J=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " " << n_sample_points
                  << "\n";
          break;
 
        case 3:
 
 
          outfile << "ZONE I=2, J=2, K=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " " << n_sample_points
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " " << n_sample_points
                  << "\n";
 
          break;
 
        default:
 
          oomph_info << "n_lagr=" << n_lagr << std::endl;
          throw OomphLibError("Wrong dimension",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

output_bin_vertices()

void RefineableBin::output_bin_vertices

(

std::ofstream &

outfile

)

Output bin vertices (allowing display of bins as zones).

Output bin; x,[y,[z]].

  {
    // Recurse?
    if (Sub_bin_array_pt != 0)
    {
      Sub_bin_array_pt->output_bin_vertices(outfile);
    }
    else
    {
      unsigned n_lagr = Bin_array_pt->ndim_zeta();
      Vector<std::pair<double, double>> min_and_max_coordinates(n_lagr);
      get_bin_boundaries(min_and_max_coordinates);
 
      switch (n_lagr)
      {
        case 1:
          outfile << "ZONE I=2\n"
                  << min_and_max_coordinates[0].first << std::endl
                  << min_and_max_coordinates[0].second << std::endl;
          break;
 
        case 2:
 
          outfile << "ZONE I=2, J=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << "\n";
          break;
 
        case 3:
 
 
          outfile << "ZONE I=2, J=2, K=2\n"
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].first << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].first << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].first << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n"
 
                  << min_and_max_coordinates[0].second << " "
                  << min_and_max_coordinates[1].second << " "
                  << min_and_max_coordinates[2].second << " "
                  << "\n";
 
          break;
 
        default:
 
          oomph_info << "n_lagr=" << n_lagr << std::endl;
          throw OomphLibError("Wrong dimension",
                              OOMPH_CURRENT_FUNCTION,
                              OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::oomph_info.

output_bins()

void RefineableBin::output_bins

(

std::ofstream &

outfile

)

Output bin vertices (allowing display of bins as zones).

total_number_of_sample_points_computed_recursively()

unsigned RefineableBin::total_number_of_sample_points_computed_recursively

(

)

const

Compute total number of sample points recursively.

  {
    unsigned count = 0;
 
    // Recurse?
    if (Sub_bin_array_pt != 0)
    {
      count =
        Sub_bin_array_pt->total_number_of_sample_points_computed_recursively();
    }
    else
    {
      if (Sample_point_pt != 0)
      {
        count = Sample_point_pt->size();
      }
    }
    return count;
  }

Member Data Documentation

Bin_array_pt

RefineableBinArray* RefineableBin::Bin_array_pt

protected

Pointer to the bin array which "owns" this RefineableBin.

Bin_index_in_bin_array

unsigned RefineableBin::Bin_index_in_bin_array

protected

Index of bin in its bin array.

Sample_point_pt

Vector<SamplePoint*>* RefineableBin::Sample_point_pt

protected

Container of SamplePoints. Pointer to vector because it's shorter than an empty vector! (Not all RefineableBins have sample points – the ones that are subdivided don't!)

Referenced by nsample_points_in_bin().

Sub_bin_array_pt

RefineableBinArray* RefineableBin::Sub_bin_array_pt

protected

Pointer to a possible sub-BinArray. Null by default.

---

The documentation for this class was generated from the following files:

• sample_point_container.h
• sample_point_container.cc