sample_point_container.h
Go to the documentation of this file.
1// LIC// ====================================================================
2// LIC// This file forms part of oomph-lib, the object-oriented,
3// LIC// multi-physics finite-element library, available
4// LIC// at http://www.oomph-lib.org.
5// LIC//
6// LIC// Copyright (C) 2006-2022 Matthias Heil and Andrew Hazel
7// LIC//
8// LIC// This library is free software; you can redistribute it and/or
9// LIC// modify it under the terms of the GNU Lesser General Public
10// LIC// License as published by the Free Software Foundation; either
11// LIC// version 2.1 of the License, or (at your option) any later version.
12// LIC//
13// LIC// This library is distributed in the hope that it will be useful,
14// LIC// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// LIC// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16// LIC// Lesser General Public License for more details.
17// LIC//
18// LIC// You should have received a copy of the GNU Lesser General Public
19// LIC// License along with this library; if not, write to the Free Software
20// LIC// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21// LIC// 02110-1301 USA.
22// LIC//
23// LIC// The authors may be contacted at oomph-lib@maths.man.ac.uk.
24// LIC//
25// LIC//====================================================================
26#ifndef OOMPH_SAMPLE_POINT_CONTAINER_HEADER
27#define OOMPH_SAMPLE_POINT_CONTAINER_HEADER
28
29#ifdef OOMPH_HAS_CGAL
30
31#include <CGAL/Cartesian_d.h>
32#include <CGAL/Search_traits_d.h>
33#include <CGAL/Search_traits_adapter.h>
34#include <boost/iterator/zip_iterator.hpp>
35#include <CGAL/Orthogonal_k_neighbor_search.h>
36
37#endif
38
39// oomph-lib includes
41#include "sparse_vector.h"
42
43/// /////////////////////////////////////////////////////////////////
44/// /////////////////////////////////////////////////////////////////
45/// /////////////////////////////////////////////////////////////////
46
47
48//=============================================================================
49/// Class for containing sample points: Number of finite element in
50/// its mesh and index of sample point within that element.
51//=============================================================================
53{
54public:
55 /// Construct SamplePoint object from number of finite element
56 /// in its mesh, and index of sample point within that element
58 const unsigned& sample_point_index_in_element)
61 {
62 }
63
64 /// Broken copy constructor.
65 SamplePoint(const SamplePoint& data) = delete;
66
67 /// Broken assignment operator.
68 void operator=(const SamplePoint&) = delete;
69
70 /// Access function to the index of finite element in its mesh
71 unsigned element_index_in_mesh() const
72 {
74 }
75
76 /// Index of sample point within element
78 {
80 }
81
82
83private:
84 /// Index of finite element in its mesh
86
87 /// Index of the sample point within element
89};
90
91
92/// /////////////////////////////////////////////////////////////////
93/// /////////////////////////////////////////////////////////////////
94/// /////////////////////////////////////////////////////////////////
95
96
97// Forward declaration of the RefineableBinArray class.
99
100
101//==============================================================================
102/// RefineableBin class. Contains sample points and is embedded in a
103/// RefineableBinArray. May itself be represented by a RefineableBinArray to
104/// make it recursive.
105//==============================================================================
107{
108public:
109 /// Constructor. Pass pointer to bin array that
110 /// contains this bin and the index of the newly created bin in that
111 /// RefineableBinArray
113 const unsigned& bin_index_in_bin_array)
114 : Sample_point_pt(0),
116 Bin_array_pt(bin_array_pt),
117 Bin_index_in_bin_array(bin_index_in_bin_array)
118 {
119 }
120
121
122 /// Broken copy constructor.
123 RefineableBin(const RefineableBin& data) = delete;
124
125 /// Broken assignment operator.
126 void operator=(const RefineableBin&) = delete;
127
128 /// Destructor
130
131 /// Compute total number of sample points recursively
133
134 /// Add a new sample point to RefineableBin
135 void add_sample_point(SamplePoint* new_sample_point_pt,
136 const Vector<double>& zeta_coordinates);
137
138 /// Find sub-GeomObject (finite element) and the local coordinate
139 /// s within it that contains point with global coordinate zeta.
140 /// sub_geom_object_pt=0 if point can't be found.
141 void locate_zeta(const Vector<double>& zeta,
142 GeomObject*& sub_geom_object_pt,
143 Vector<double>& s);
144
145 /// Output bin; x,[y,[z]],n_sample_points
146 void output(std::ofstream& outfile, const bool& don_t_recurse = false);
147
148 /// Output bin vertices (allowing display of bins as zones).
149 void output_bins(std::ofstream& outfile);
150
151 /// Output bin vertices (allowing display of bins as zones).
152 void output_bin_vertices(std::ofstream& outfile);
153
154 /// Number of sample points stored in bin
156 {
157 if (Sample_point_pt == 0)
158 {
159 return 0;
160 }
161 else
162 {
163 return Sample_point_pt->size();
164 }
165 }
166
167protected:
168 /// Container of SamplePoints. Pointer to vector because it's shorter
169 /// than an empty vector! (Not all RefineableBins have sample
170 /// points -- the ones that are subdivided don't!)
171 Vector<SamplePoint*>* Sample_point_pt;
172
173 /// Pointer to a possible sub-BinArray. Null by default
175
176 /// Pointer to the bin array which "owns" this RefineableBin.
178
179 /// Index of bin in its bin array
181
182 /// Method for building a new subbin_array (called when the Bin size
183 /// is greater than the Max_number_of_sample_point_per_bin (and the Bin is
184 /// recursive). Pass in the extremal coordinates of the bin which is
185 /// being subdivided. Redistributes all existing sample points to
186 /// newly made sub-bin-array and empties its own storage. Pass
187 /// Max./min. coordinates of new bin array for efficiency.
189 const Vector<std::pair<double, double>>& min_and_max_coordinates);
190
191 /// Boundaries of bin in each coordinate direction.
192 /// *.first = min; *.second = max
194 Vector<std::pair<double, double>>& min_and_max_coordinates);
195};
196
197
198/// /////////////////////////////////////////////////////////////////////
199/// /////////////////////////////////////////////////////////////////////
200/// /////////////////////////////////////////////////////////////////////
201
202//=========================================================================
203/// Base class for all sample point containers
204//=========================================================================
206{
207public:
208 /// Constructor
210 Mesh* mesh_pt,
211 const Vector<std::pair<double, double>>& min_and_max_coordinates,
215 : Mesh_pt(mesh_pt),
219#ifdef OOMPH_HAS_MPI
222#endif
226 {
227 // Don't limit max. search radius
228 Max_search_radius = DBL_MAX;
229 }
230
231 /// Broken default constructor; needed for broken
232 /// copy constructors. Don't call. It will die.
234 {
235 // Throw the error
236 throw OomphLibError("Broken default constructor. Don't call this!",
237 OOMPH_CURRENT_FUNCTION,
238 OOMPH_EXCEPTION_LOCATION);
239 }
240
241 /// Broken copy constructor.
243
244 /// Broken assignment operator.
245 void operator=(const SamplePointContainer&) = delete;
246
247 /// Virtual destructor
249
250 /// Find sub-GeomObject (finite element) and the local coordinate
251 /// s within it that contains point with global coordinate zeta.
252 /// sub_geom_object_pt=0 if point can't be found.
253 virtual void locate_zeta(const Vector<double>& zeta,
254 GeomObject*& sub_geom_object_pt,
255 Vector<double>& s) = 0;
256
257
258 /// Counter to keep track of how many sample points we've
259 /// visited during top level call to locate_zeta. Virtual so it can be
260 /// overloaded for different versions.
262 {
264 }
265
266 /// Total number of sample points in sample point container, possibly
267 /// computed recursively.
269 const = 0;
270
271 /// Dimension of the zeta ( = dim of local coordinate of elements)
272 virtual unsigned ndim_zeta() const = 0;
273
274 /// Pointer to mesh from whose FiniteElements sample points are created
275 Mesh* mesh_pt() const
276 {
277 return Mesh_pt;
278 }
279
280 /// Pair of doubles for min and maximum coordinates in i-th direction:
281 /// min (first) and max. (second) coordinates
282 const std::pair<double, double>& min_and_max_coordinates(
283 const unsigned& i) const
284 {
286 }
287
288 /// Vector of pair of doubles for min and maximum coordinates.
289 /// min (first) and max. (second) coordinates
290 const Vector<std::pair<double, double>>& min_and_max_coordinates() const
291 {
293 }
294
295
296#ifdef OOMPH_HAS_MPI
297
298 /// Ignore halo elements?
300 {
302 }
303
304#endif
305
306 /// Use Eulerian coordinates (i.e. interpolated_x) rather than
307 /// zeta itself (i.e. interpolated_zeta) to identify point.
309 {
311 }
312
313 /// "Measure of" number of sample points generated in each element
315 {
317 }
318
319 /// Set maximum search radius for locate zeta. This is initialised
320 /// do DBL_MAX so we brutally search through the entire bin structure,
321 /// no matter how big it is until we've found the required point (or
322 /// failed to do so. This can be VERY costly with fine meshes.
323 /// Here the user takes full responsibility and states that we have
324 /// no chance in hell to find the required point in
325 /// a bin whose closest vertex is further than the specified
326 /// max search radius.
328 {
329 return Max_search_radius;
330 }
331
332
333 /// File to record sequence of visited sample points in. Used for debugging/
334 /// illustration of search procedures.
335 static std::ofstream Visited_sample_points_file;
336
337 /// Boolean flag to make to make locate zeta fail. Used for debugging/
338 /// illustration of search procedures.
340
341 /// Use equally spaced sample points? (otherwise vertices are sampled
342 /// repeatedly
344
345 /// Time setup?
347
348 /// Offset of sample point container boundaries beyond max/min coords
349 static double Percentage_offset;
350
351protected:
352 /// Helper function to compute the min and max coordinates for the
353 /// mesh, in each dimension
355
356 /// Pointer to mesh from whose FiniteElements sample points are created
357 Mesh* Mesh_pt;
358
359 /// Vector of pairs of doubles for min and maximum coordinates.
360 /// Call: Min_and_max_coordinates[j] gives me the
361 /// pair of min (first) and max. (second) coordinates in the j-th
362 /// coordinate direction.
363 Vector<std::pair<double, double>> Min_and_max_coordinates;
364
365 /// Use Eulerian coordinates (i.e. interpolated_x) rather than
366 /// zeta itself (i.e. interpolated_zeta) to identify point.
368
369#ifdef OOMPH_HAS_MPI
370
371 /// Ignore halo elements?
373
374#endif
375
376 /// "Measure of" number of sample points generated in each element
378
379 /// Counter to keep track of how many sample points we've
380 /// visited during top level call to locate_zeta
381 unsigned
383
384 /// Max radius beyond which we stop searching the bin. Initialised
385 /// to DBL_MAX so keep going until the point is found or until
386 /// we've searched every single bin. Overwriting this means we won't search
387 /// in bins whose closest vertex is at a distance greater than
388 /// Max_search_radius from the point to be located.
390};
391
392
393/// /////////////////////////////////////////////////////////////////////
394/// /////////////////////////////////////////////////////////////////////
395/// /////////////////////////////////////////////////////////////////////
396
397
398//=========================================================================
399/// Base class for all bin arrays
400//=========================================================================
401class BinArray : public virtual SamplePointContainer
402{
403public:
404 /// Constructor
406 const Vector<std::pair<double, double>>& min_and_max_coordinates,
407 const Vector<unsigned>& dimensions_of_bin_array,
417 {
418 // Note: Resizing of Dimensions_of_bin_array if no sizes are specified
419 // is delayed to derived class since refineable and nonrefineable
420 // bin arrays have different defaults.
421 }
422
423 /// Broken default constructor; needed for broken
424 /// copy constructors. Don't call. It will die.
426 {
427 // Throw the error
428 throw OomphLibError("Broken default constructor. Don't call this!",
429 OOMPH_CURRENT_FUNCTION,
430 OOMPH_EXCEPTION_LOCATION);
431 }
432
433 /// Broken copy constructor.
434 BinArray(const BinArray& data) = delete;
435
436 /// Broken assignment operator.
437 void operator=(const BinArray&) = delete;
438
439 /// Virtual destructor
440 virtual ~BinArray() {}
441
442 /// Helper function for computing the bin indices of neighbouring bins
443 /// at a given "radius" of the specified bin. Final, optional boolean
444 /// (default: true) chooses to use the old version which appears to be
445 /// faster than Louis' new one after all (in the few cases where this
446 /// functionality is still used -- not all if we have cgal!)
447 void get_neighbouring_bins_helper(const unsigned& bin_index,
448 const unsigned& radius,
449 Vector<unsigned>& neighbouring_bin_index,
450 const bool& use_old_version = true);
451
452 /// Profiling function to compare performance of two different
453 /// versions of the get_neighbouring_bins_helper(...) function
455
456
457 /// Get (linearly enumerated) bin index of bin that
458 /// contains specified zeta
459 unsigned coords_to_bin_index(const Vector<double>& zeta);
460
461
462 /// Get "coordinates" of bin that contains specified zeta
463 void coords_to_vectorial_bin_index(const Vector<double>& zeta,
464 Vector<unsigned>& bin_index);
465
466 /// Output bins (boundaries and number of sample points in them)
467 virtual void output_bins(std::ofstream& outfile) = 0;
468
469 /// Output bin vertices (allowing display of bin boundaries as zones).
470 virtual void output_bin_vertices(std::ofstream& outfile) = 0;
471
472 /// Number of bins (not taking recursion into account for refineable
473 /// versions)
474 virtual unsigned nbin() const = 0;
475
476 /// Max. bin dimension (number of bins in coordinate directions)
477 unsigned max_bin_dimension() const;
478
479 /// Dimension of the zeta ( = dim of local coordinate of elements)
480 unsigned ndim_zeta() const
481 {
482 return Dimensions_of_bin_array.size();
483 }
484
485 /// Number of bins in coordinate direction i
486 unsigned dimension_of_bin_array(const unsigned& i) const
487 {
489 }
490
491
492 /// Number of bins in coordinate directions. Const vector-based
493 /// version
494 Vector<unsigned> dimensions_of_bin_array() const
495 {
497 }
498
499
500 /// Number of bins in specified coordinate direction
501 unsigned dimensions_of_bin_array(const unsigned& i) const
502 {
504 }
505
506protected:
507 /// Number of bins in each coordinate direction
508 Vector<unsigned> Dimensions_of_bin_array;
509};
510
511
512/// /////////////////////////////////////////////////////////////////////
513/// /////////////////////////////////////////////////////////////////////
514/// /////////////////////////////////////////////////////////////////////
515
516
517//==============================================================================
518/// RefineableBinArray class.
519//==============================================================================
520class RefineableBinArray : public virtual BinArray
521{
522public:
523 /// Constructor
524 RefineableBinArray(SamplePointContainerParameters* bin_array_parameters_pt);
525
526 /// Broken copy constructor.
528
529 /// Broken assignment operator.
530 void operator=(const RefineableBinArray&) = delete;
531
532 /// Destructor
534 {
535 unsigned n = Bin_pt.size();
536 for (unsigned i = 0; i < n; i++)
537 {
538 if (Bin_pt[i] != 0)
539 {
540 delete Bin_pt[i];
541 Bin_pt[i] = 0;
542 }
543 }
544 }
545
546 /// Root bin array
548 {
549 return Root_bin_array_pt;
550 }
551
552 /// Pointer to i-th bin; can be null if bin is empty
553 RefineableBin* bin_pt(const unsigned& i) const
554 {
555 return Bin_pt[i];
556 }
557
558 /// Number of bins (not taking recursion into account)
559 unsigned nbin() const
560 {
561 return Bin_pt.size();
562 }
563
564 /// Default number of bins (in each coordinate direction)
565 /// (Note: don't move this into a common base class because
566 /// each derived class has its own value; we'll want far fewer
567 /// in the refineable version!)
568 static unsigned Default_n_bin_1d;
569
570 /// Compute total number of sample points recursively
572
573 /// Fill the bin array with specified SamplePoints
574 void fill_bin_array(const Vector<SamplePoint*>& sample_point_pt)
575 {
576 unsigned n_dim = ndim_zeta();
577
578 unsigned n = sample_point_pt.size();
579 for (unsigned i = 0; i < n; i++)
580 {
581 // Coordinates of this point
582 Vector<double> zeta(n_dim);
583
584 // Which element is the point in?
585 unsigned e = sample_point_pt[i]->element_index_in_mesh();
586 FiniteElement* el_pt = Mesh_pt->finite_element_pt(e);
587
588 // Which sample point is it at?
589 unsigned j = sample_point_pt[i]->sample_point_index_in_element();
590 Vector<double> s(n_dim);
591 bool use_equally_spaced_interior_sample_points =
593 el_pt->get_s_plot(j,
595 s,
596 use_equally_spaced_interior_sample_points);
598 {
599 el_pt->interpolated_x(s, zeta);
600 }
601 else
602 {
603 el_pt->interpolated_zeta(s, zeta);
604 }
605
606 // Add it
607 add_sample_point(sample_point_pt[i], zeta);
608 }
609 }
610
611 /// Add specified SamplePoint to RefineableBinArray
612 void add_sample_point(SamplePoint* new_sample_point_pt,
613 const Vector<double>& zeta)
614 {
615 // Find the correct bin
616 unsigned bin_index = coords_to_bin_index(zeta);
617
618 // if the bin is not yet created, create it...
619 if (Bin_pt[bin_index] == 0)
620 {
621 Bin_pt[bin_index] = new RefineableBin(this, bin_index);
622 }
623 // Then add the SamplePoint
624 Bin_pt[bin_index]->add_sample_point(new_sample_point_pt, zeta);
625 }
626
627 /// Find sub-GeomObject (finite element) and the local coordinate
628 /// s within it that contains point with global coordinate zeta.
629 /// sub_geom_object_pt=0 if point can't be found.
630 void locate_zeta(const Vector<double>& zeta,
631 GeomObject*& sub_geom_object_pt,
632 Vector<double>& s);
633
634 /// Boundaries of specified bin in each coordinate direction.
635 /// *.first = min; *.second = max.
637 const unsigned& bin_index,
638 Vector<std::pair<double, double>>& min_and_max_coordinates);
639
640 /// Depth of the hierarchical bin_array.
641 unsigned depth() const
642 {
643 return Depth;
644 }
645
646 /// Max depth of the hierarchical bin_array; const version
647 unsigned max_depth() const
648 {
649 return Max_depth;
650 }
651
652 /// Max depth of the hierarchical bin_array
653 unsigned& max_depth()
654 {
655 return Max_depth;
656 }
657
658 /// Is the BinArray recursive?
660 {
662 }
663
664 /// Maximum number of sample points in bin (before its subdivided
665 /// recursively)
667 {
669 }
670
671 /// Output bins
672 void output_bins(std::ofstream& outfile)
673 {
674 /// Loop over bins
675 unsigned n_bin = Bin_pt.size();
676 for (unsigned i = 0; i < n_bin; i++)
677 {
678 if (Bin_pt[i] != 0)
679 {
680 Bin_pt[i]->output(outfile);
681 }
682 }
683 }
684
685 /// Output bin vertices (allowing display of bins as zones).
686 void output_bin_vertices(std::ofstream& outfile);
687
688 /// Output neighbouring bins at given "radius" of the specified bin
689 void output_neighbouring_bins(const unsigned& bin_index,
690 const unsigned& radius,
691 std::ofstream& outfile);
692
693
694 /// Counter to keep track of how many sample points we've
695 /// visited during top level call to locate_zeta
697 {
698 if (Depth == 0)
699 {
701 }
702 else
703 {
704 return Root_bin_array_pt
706 }
707 }
708
709 /// When searching through sample points recursively from the top
710 /// level RefineableBinArray (in deterministic order!) only actually do the
711 /// locate_zeta calls when when the counter exceeds this value.
713 {
715 }
716
717 /// When searching through sample points recursively from the top
718 /// level RefineableBinArray (in deterministic order!) only actually do the
719 /// locate_zeta calls when when the counter is less than this value.
721 {
723 }
724
725 /// Every time we've completed a "spiral", visiting a finite
726 /// number of sample points in a deterministic order, use this
727 /// multiplier to increase the max. number of sample points to be visited.
728 /// Using a multiplier rather than a constant increment increases
729 /// the amount of (more and more unlikely to yield anything!) work
730 /// done locally before doing another costly mpi round trip
731 /// when we're already far from the point we're trying to find.
733 {
735 }
736
737 /// When searching through sample points recursively from the top
738 /// level RefineableBinArray (in deterministic order!) only actually do the
739 /// locate_zeta calls when when the counter exceeds this value.
740 /// This is the initial value when starting the spiral based search.
742 {
744 }
745
746
747private:
748 /// Fill the bin array with sample points from FiniteElements stored in mesh
749 void fill_bin_array();
750
751 /// Loop over all sample points in the element specified via the
752 /// pointer and create a SamplePoint for each. Also specify the index of the
753 /// element in its mesh.
754 void create_sample_points_from_element(FiniteElement* const element_pt,
755 const unsigned& n_element);
756
757
758 /// Vector of pointers to constituent RefineableBins.
759 Vector<RefineableBin*> Bin_pt;
760
761 /// Variable which stores if the RefineableBinArray is
762 /// recursive or not.
764
765 /// Variable which stores the Depth value of the bin_array. Useful for
766 /// debugging and for preventing "infinite" recursion in case if there is
767 /// a problem.
768 unsigned Depth;
769
770 /// Max depth of the hierarchical bin_array
771 unsigned Max_depth;
772
773 /// Maximum number of sample points in bin (before it's subdivided
774 /// recursively)
776
777 /// Pointer to root bin array
779
780 // hierher only used in root
781
782 /// When searching through sample points recursively from the top
783 /// level RefineableBinArray (in deterministic order!) only actually do the
784 /// locate_zeta calls when when the counter exceeds this value.
786
787 /// When searching through sample points recursively from the top
788 /// level RefineableBinArray (in deterministic order!) only actually do the
789 /// locate_zeta calls when when the counter is less than this value.
791
792 /// Every time we've completed a "spiral", visiting a finite
793 /// number of sample points in a deterministic order, use this
794 /// multiplier to increase the max. number of sample points to be visited.
795 /// Using a multiplier rather than a constant increment increases
796 /// the amount of (more and more unlikely to yield anything!) work
797 /// done locally before doing another costly mpi round trip
798 /// when we're already far from the point we're trying to find.
799 unsigned
801
802 /// When searching through sample points recursively from the top
803 /// level RefineableBinArray (in deterministic order!) only actually do the
804 /// locate_zeta calls when when the counter exceeds this value.
805 /// This is the initial value when starting the spiral based search.
807};
808
809
810/// /////////////////////////////////////////////////////////////////////////////
811/// /////////////////////////////////////////////////////////////////////////////
812/// /////////////////////////////////////////////////////////////////////////////
813
814
815//==============================================================================
816/// NonRefineableBinArray class.
817//==============================================================================
818class NonRefineableBinArray : public virtual BinArray
819{
820public:
821 /// Constructor
823 SamplePointContainerParameters* bin_array_parameters_pt);
824
825 /// Destructor:
827 {
829 }
830
831 /// Broken copy constructor.
833
834 /// Broken assignment operator.
835 void operator=(const NonRefineableBinArray&) = delete;
836
837 /// Find sub-GeomObject (finite element) and the local coordinate
838 /// s within it that contains point with global coordinate zeta.
839 /// sub_geom_object_pt=0 if point can't be found.
840 void locate_zeta(const Vector<double>& zeta,
841 GeomObject*& sub_geom_object_pt,
842 Vector<double>& s);
843
844 /// Total number of bins (empty or not)
845 unsigned nbin() const
846 {
847 const unsigned n_lagrangian = ndim_zeta();
848 unsigned ntotalbin = Dimensions_of_bin_array[0];
849 for (unsigned i = 1; i < n_lagrangian; i++)
850 {
851 ntotalbin *= Dimensions_of_bin_array[i];
852 }
853 return ntotalbin;
854 }
855
856 /// Default number of bins (in each coordinate direction).
857 /// (Note: don't move this into a common base class because
858 /// each derived class has its own value; nonrefineable bin
859 /// wants a much larger value than the refineable one!)
860 static unsigned Default_n_bin_1d;
861
862 /// Compute total number of sample points recursively
864
865 /// Number of spirals to be searched in one go const version
866 unsigned n_spiral_chunk() const
867 {
868 return Nspiral_chunk;
869 }
870
871 /// Number of spirals to be searched in one go
872 unsigned& n_spiral_chunk()
873 {
874 return Nspiral_chunk;
875 }
876
877 /// Access function to max. spiral level during straight locate_zeta
878 /// search (for efficiency; similar to max_search_radius())
880 {
881 return Max_spiral_level;
882 }
883
884 /// Access function to current min. spiral level
886 {
888 }
889
890 /// Access function to current max. spiral level
892 {
894 }
895
896 /// Provide some stats on the fill level of the associated bin
897 void get_fill_stats(unsigned& n_bin,
898 unsigned& max_n_entry,
899 unsigned& min_n_entry,
900 unsigned& tot_n_entry,
901 unsigned& n_empty) const;
902
903 /// Compute the minimum distance of any vertex in the specified bin
904 /// from the specified Lagrangian coordinate zeta
905 double min_distance(const unsigned& i_bin, const Vector<double>& zeta);
906
907 /// Output bin vertices (allowing display of bins as zones).
908 void output_bin_vertices(std::ofstream& outfile);
909
910 /// Get vector of vectors containing the coordinates of the
911 /// vertices of the i_bin-th bin: bin_vertex[j][i] contains the
912 /// i-th coordinate of the j-th vertex.
913 void get_bin_vertices(const unsigned& i_bin,
914 Vector<Vector<double>>& bin_vertex);
915
916 /// Get the number of the bin containing the specified coordinate.
917 /// Bin number is negative if the coordinate is outside
918 /// the bin structure.
919 void get_bin(const Vector<double>& zeta, int& bin_number);
920
921 /// Get the number of the bin containing the specified coordinate; also
922 /// return the contents of that bin. Bin number is negative if the
923 /// coordinate is outside the bin structure.
925 const Vector<double>& zeta,
926 int& bin_number,
927 Vector<std::pair<FiniteElement*, Vector<double>>>& sample_point_pairs);
928
929 /// Get the contents of all bins in vector
930 Vector<Vector<std::pair<FiniteElement*, Vector<double>>>> bin_content() const
931 {
932 Vector<Vector<std::pair<FiniteElement*, Vector<double>>>> all_vals;
933 Bin_object_coord_pairs.get_all_values(all_vals);
934 return all_vals;
935 }
936
937 /// Get the contents of all bins in vector
938 const std::map<unsigned, Vector<std::pair<FiniteElement*, Vector<double>>>>* get_all_bins_content()
939 const
940 {
941 // Return the content of the bins
942 return Bin_object_coord_pairs.map_pt();
943 }
944
945 /// Fill bin by diffusion, populating each empty bin with the
946 /// same content as the first non-empty bin found during a spiral-based search
947 /// up to the specified "radius" (default 1)
948 void fill_bin_by_diffusion(const unsigned& bin_diffusion_radius = 1);
949
950
951 /// Output bins
952 void output_bins(std::ofstream& outfile);
953
954 /// Output bins
955 void output_bins(std::string& filename)
956 {
957 std::ofstream outfile;
958 outfile.open(filename.c_str());
959 output_bins(outfile);
960 outfile.close();
961 }
962
963 /// Counter for overall number of bins allocated -- used to
964 /// issue warning if this exceeds a threshhold. (Default assignment
965 /// of 100^DIM bins per MeshAsGeomObject can be a killer if there
966 /// are huge numbers of sub-meshes (e.g. in unstructured FSI).
967 static unsigned long Total_nbin_cells_counter;
968
969 /// Total number of bins above which warning is issued.
970 /// (Default assignment of 100^DIM bins per MeshAsGeomObject can
971 /// be a killer if there are huge numbers of sub-meshes (e.g. in
972 /// unstructured FSI).
974
975 /// Boolean to supppress warnings about large number of bins
977
978 /// Boolean flag to make sure that warning about large number
979 /// of bin cells only gets triggered once.
981
982 /// Fraction of elements/bin that triggers warning. Too many
983 /// elements per bin can lead to very slow computations
985
986 /// Boolean to supppress warnings about small number of bins
988
989 /// Boolean flag to make sure that warning about small number
990 /// of bin cells only gets triggered once.
992
993private:
994 /// Fill the bin array with sample points from FiniteElements stored in mesh
995 void fill_bin_array();
996
997 /// Initialise and populate the "bin" structure for locating coordinates
998 /// and increment counter for total number of bins in active use by any
999 /// MeshAsGeomObject)
1001
1002 /// Flush the storage for the binning method (and decrement counter
1003 /// for total number of bins in active use by any MeshAsGeomObject)
1005 {
1007 Bin_object_coord_pairs.clear();
1008 }
1009
1010 /// Storage for paired objects and coords in each bin
1011 SparseVector<Vector<std::pair<FiniteElement*, Vector<double>>>>
1013
1014 /// Max. spiralling level (for efficiency; effect similar to
1015 /// max_search_radius)
1017
1018 /// Current min. spiralling level
1020
1021 /// Current max. spiralling level
1023
1024 /// Number of spirals to be searched in one go
1026};
1027
1028
1029/// /////////////////////////////////////////////////////////////////////
1030/// /////////////////////////////////////////////////////////////////////
1031/// /////////////////////////////////////////////////////////////////////
1032
1033#ifdef OOMPH_HAS_CGAL
1034
1035
1036//====================================================================
1037/// CGAL-based SamplePointContainer
1038//====================================================================
1040{
1041public:
1042 /// Constructor
1044 SamplePointContainerParameters* sample_point_container_parameters_pt);
1045
1046 /// Broken copy constructor.
1048
1049 /// Broken assignment operator.
1051
1052 /// Virtual destructor
1054 {
1055 unsigned n = Sample_point_pt.size();
1056 for (unsigned i = 0; i < n; i++)
1057 {
1058 delete Sample_point_pt[i];
1059 Sample_point_pt[i] = 0;
1060 }
1061 delete CGAL_tree_d_pt;
1062 CGAL_tree_d_pt = 0;
1063 }
1064
1065 /// When searching through sample points only actually do the
1066 /// locate_zeta calls when when the counter exceeds this value.
1068 {
1070 }
1071
1072 /// When searching through sample points only actually do the
1073 /// locate_zeta calls when when the counter is less than this value.
1075 {
1077 }
1078
1079
1080 /// Every time we've completed a "spiral", visiting a finite
1081 /// number of sample points in a deterministic order, use this
1082 /// multiplier to increase the max. number of sample points to be visited.
1083 /// Using a multiplier rather than a constant increment increases
1084 /// the amount of (more and more unlikely to yield anything!) work
1085 /// done locally before doing another costly mpi round trip
1086 /// when we're already far from the point we're trying to find.
1088 {
1090 }
1091
1092 /// When searching through sample points only actually do the
1093 /// locate_zeta calls when when the counter exceeds this value.
1094 /// This is the initial value when starting the spiral based search.
1096 {
1098 }
1099
1100
1101 /// Find sub-GeomObject (finite element) and the local coordinate
1102 /// s within it that contains point with global coordinate zeta.
1103 /// sub_geom_object_pt=0 if point can't be found.
1104 void locate_zeta(const Vector<double>& zeta,
1105 GeomObject*& sub_geom_object_pt,
1106 Vector<double>& s);
1107
1108
1109 /// Find the sub geometric object and local coordinate therein that
1110 /// corresponds to the intrinsic coordinate zeta, using up to the specified
1111 /// number of sample points as initial guess for the Newton-based search.
1112 /// If this fails, return the nearest sample point.
1114 const Vector<double>& zeta,
1115 const unsigned& max_sample_points_for_newton_based_search,
1116 GeomObject*& sub_geom_object_pt,
1117 Vector<double>& s);
1118
1119
1120 /// Dimension of the zeta ( = dim of local coordinate of elements)
1121 unsigned ndim_zeta() const
1122 {
1123 return Ndim_zeta;
1124 }
1125
1126 /// Compute total number of sample points in sample point container
1128
1129private:
1130 /// Get the sample points; return time for setup of CGAL tree.
1131 double get_sample_points();
1132
1133 /// Dimension of the zeta ( = dim of local coordinate of elements)
1134 unsigned Ndim_zeta;
1135
1136 /// typedefs for cgal stuff
1137 typedef CGAL::Cartesian_d<double> Kernel_d;
1138 typedef Kernel_d::Point_d Point_d;
1139 typedef boost::tuple<Point_d, SamplePoint*> Point_d_and_pointer;
1140 typedef CGAL::Search_traits_d<Kernel_d> Traits_base_d;
1141 typedef CGAL::Search_traits_adapter<
1143 CGAL::Nth_of_tuple_property_map<0, Point_d_and_pointer>,
1146 typedef CGAL::Orthogonal_k_neighbor_search<Traits_d> K_neighbor_search_d;
1147
1148 /// Vector containing sample point coordinates
1150
1151 /// Pointer to tree-based representation of sample points
1152 K_neighbor_search_d::Tree* CGAL_tree_d_pt;
1153
1154 /// Vector storing pointers to sample point objects (which represent
1155 /// sample point in terms of number of element
1156 /// in its mesh and number of sample point)
1157 Vector<SamplePoint*> Sample_point_pt;
1158
1159 /// When searching through sample points only actually do the
1160 /// locate_zeta calls when when the counter exceeds this value.
1162
1163 /// When searching through sample points only actually do the
1164 /// locate_zeta calls when when the counter is less than this value.
1166
1167 /// Every time we've completed a "spiral", visiting a finite
1168 /// number of sample points in a deterministic order, use this
1169 /// multiplier to increase the max. number of sample points to be visited.
1170 /// Using a multiplier rather than a constant increment increases
1171 /// the amount of (more and more unlikely to yield anything!) work
1172 /// done locally before doing another costly mpi round trip
1173 /// when we're already far from the point we're trying to find.
1174 unsigned
1176
1177 /// When searching through sample points only actually do the
1178 /// locate_zeta calls when when the counter exceeds this value.
1179 /// This is the initial value when starting the "spiral based" search.
1181};
1182
1183#endif // endif oomph has cgal
1184
1185/// /////////////////////////////////////////////////////////////////////
1186/// /////////////////////////////////////////////////////////////////////
1187/// /////////////////////////////////////////////////////////////////////
1188
1189
1190} // end of namespace extension
1191
1192#endif
e
Definition: cfortran.h:571
static char t char * s
Definition: cfortran.h:568
cstr elem_len * i
Definition: cfortran.h:603
///////////////////////////////////////////////////////////////////// ///////////////////////////////...
unsigned dimension_of_bin_array(const unsigned &i) const
Number of bins in coordinate direction i.
unsigned max_bin_dimension() const
Max. bin dimension (number of bins in coordinate directions)
Vector< unsigned > dimensions_of_bin_array() const
Number of bins in coordinate directions. Const vector-based version.
virtual void output_bins(std::ofstream &outfile)=0
Output bins (boundaries and number of sample points in them)
void get_neighbouring_bins_helper(const unsigned &bin_index, const unsigned &radius, Vector< unsigned > &neighbouring_bin_index, const bool &use_old_version=true)
Helper function for computing the bin indices of neighbouring bins at a given "radius" of the specifi...
unsigned dimensions_of_bin_array(const unsigned &i) const
Number of bins in specified coordinate direction.
unsigned ndim_zeta() const
Dimension of the zeta ( = dim of local coordinate of elements)
Vector< unsigned > Dimensions_of_bin_array
Number of bins in each coordinate direction.
virtual unsigned nbin() const =0
Number of bins (not taking recursion into account for refineable versions)
virtual ~BinArray()
Virtual destructor.
BinArray(const BinArray &data)=delete
Broken copy constructor.
BinArray()
Broken default constructor; needed for broken copy constructors. Don't call. It will die.
BinArray(Mesh *mesh_pt, const Vector< std::pair< double, double > > &min_and_max_coordinates, const Vector< unsigned > &dimensions_of_bin_array, const bool &use_eulerian_coordinates_during_setup, const bool &ignore_halo_elements_during_locate_zeta_search, const unsigned &nsample_points_generated_per_element)
Constructor.
unsigned coords_to_bin_index(const Vector< double > &zeta)
Get (linearly enumerated) bin index of bin that contains specified zeta.
void profile_get_neighbouring_bins_helper()
Profiling function to compare performance of two different versions of the get_neighbouring_bins_help...
void operator=(const BinArray &)=delete
Broken assignment operator.
void coords_to_vectorial_bin_index(const Vector< double > &zeta, Vector< unsigned > &bin_index)
Get "coordinates" of bin that contains specified zeta.
virtual void output_bin_vertices(std::ofstream &outfile)=0
Output bin vertices (allowing display of bin boundaries as zones).
///////////////////////////////////////////////////////////////////// ///////////////////////////////...
void 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 gl...
unsigned ndim_zeta() const
Dimension of the zeta ( = dim of local coordinate of elements)
CGALSamplePointContainer(const CGALSamplePointContainer &data)=delete
Broken copy constructor.
CGAL::Orthogonal_k_neighbor_search< Traits_d > K_neighbor_search_d
unsigned & multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta()
Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic o...
CGALSamplePointContainer(SamplePointContainerParameters *sample_point_container_parameters_pt)
Constructor.
unsigned & initial_last_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points only actually do the locate_zeta calls when when the counter exc...
void limited_locate_zeta(const Vector< double > &zeta, const unsigned &max_sample_points_for_newton_based_search, GeomObject *&sub_geom_object_pt, Vector< double > &s)
Find the sub geometric object and local coordinate therein that corresponds to the intrinsic coordina...
unsigned Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta
Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic o...
unsigned & last_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points only actually do the locate_zeta calls when when the counter is ...
unsigned Last_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points only actually do the locate_zeta calls when when the counter is ...
Vector< SamplePoint * > Sample_point_pt
Vector storing pointers to sample point objects (which represent sample point in terms of number of e...
virtual ~CGALSamplePointContainer()
Virtual destructor.
double get_sample_points()
Get the sample points; return time for setup of CGAL tree.
unsigned Initial_last_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points only actually do the locate_zeta calls when when the counter exc...
CGAL::Cartesian_d< double > Kernel_d
typedefs for cgal stuff
unsigned First_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points only actually do the locate_zeta calls when when the counter exc...
Vector< Point_d > CGAL_sample_point_zeta_d
Vector containing sample point coordinates.
K_neighbor_search_d::Tree * CGAL_tree_d_pt
Pointer to tree-based representation of sample points.
unsigned & first_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points only actually do the locate_zeta calls when when the counter exc...
unsigned Ndim_zeta
Dimension of the zeta ( = dim of local coordinate of elements)
boost::tuple< Point_d, SamplePoint * > Point_d_and_pointer
CGAL::Search_traits_d< Kernel_d > Traits_base_d
unsigned total_number_of_sample_points_computed_recursively() const
Compute total number of sample points in sample point container.
void operator=(const CGALSamplePointContainer &)=delete
Broken assignment operator.
CGAL::Search_traits_adapter< Point_d_and_pointer, CGAL::Nth_of_tuple_property_map< 0, Point_d_and_pointer >, Traits_base_d > Traits_d
///////////////////////////////////////////////////////////////////////////// ///////////////////////...
static bool Already_warned_about_small_number_of_bin_cells
Boolean flag to make sure that warning about small number of bin cells only gets triggered once.
void get_bin(const Vector< double > &zeta, int &bin_number)
Get the number of the bin containing the specified coordinate. Bin number is negative if the coordina...
static bool Suppress_warning_about_large_total_number_of_bins
Boolean to supppress warnings about large number of bins.
void fill_bin_array()
Fill the bin array with sample points from FiniteElements stored in mesh.
void create_bins_of_objects()
Initialise and populate the "bin" structure for locating coordinates and increment counter for total ...
unsigned n_spiral_chunk() const
Number of spirals to be searched in one go const version.
unsigned Nspiral_chunk
Number of spirals to be searched in one go.
unsigned Max_spiral_level
Max. spiralling level (for efficiency; effect similar to max_search_radius)
static unsigned long Total_nbin_cells_counter
Counter for overall number of bins allocated – used to issue warning if this exceeds a threshhold....
void operator=(const NonRefineableBinArray &)=delete
Broken assignment operator.
void 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 gl...
static unsigned Threshold_for_elements_per_bin_warning
Fraction of elements/bin that triggers warning. Too many elements per bin can lead to very slow compu...
unsigned Current_min_spiral_level
Current min. spiralling level.
unsigned & max_spiral_level()
Access function to max. spiral level during straight locate_zeta search (for efficiency; similar to m...
unsigned Current_max_spiral_level
Current max. spiralling level.
static bool Suppress_warning_about_small_number_of_bins
Boolean to supppress warnings about small number of bins.
unsigned & current_min_spiral_level()
Access function to current min. spiral level.
void fill_bin_by_diffusion(const unsigned &bin_diffusion_radius=1)
Fill bin by diffusion, populating each empty bin with the same content as the first non-empty bin fou...
unsigned & n_spiral_chunk()
Number of spirals to be searched in one go.
void get_bin_vertices(const unsigned &i_bin, Vector< Vector< double > > &bin_vertex)
Get vector of vectors containing the coordinates of the vertices of the i_bin-th bin: bin_vertex[j][i...
void output_bins(std::string &filename)
Output bins.
unsigned total_number_of_sample_points_computed_recursively() const
Compute total number of sample points recursively.
void get_bin(const Vector< double > &zeta, int &bin_number, Vector< std::pair< FiniteElement *, Vector< double > > > &sample_point_pairs)
Get the number of the bin containing the specified coordinate; also return the contents of that bin....
const std::map< unsigned, Vector< std::pair< FiniteElement *, Vector< double > > > > * get_all_bins_content() const
Get the contents of all bins in vector.
NonRefineableBinArray(const NonRefineableBinArray &data)=delete
Broken copy constructor.
void output_bin_vertices(std::ofstream &outfile)
Output bin vertices (allowing display of bins as zones).
static bool Already_warned_about_large_number_of_bin_cells
Boolean flag to make sure that warning about large number of bin cells only gets triggered once.
SparseVector< Vector< std::pair< FiniteElement *, Vector< double > > > > Bin_object_coord_pairs
Storage for paired objects and coords in each bin.
void output_bins(std::ofstream &outfile)
Output bins.
static unsigned Default_n_bin_1d
Default number of bins (in each coordinate direction). (Note: don't move this into a common base clas...
void get_fill_stats(unsigned &n_bin, unsigned &max_n_entry, unsigned &min_n_entry, unsigned &tot_n_entry, unsigned &n_empty) const
Provide some stats on the fill level of the associated bin.
void flush_bins_of_objects()
Flush the storage for the binning method (and decrement counter for total number of bins in active us...
static unsigned long Threshold_for_total_bin_cell_number_warning
Total number of bins above which warning is issued. (Default assignment of 100^DIM bins per MeshAsGeo...
NonRefineableBinArray(SamplePointContainerParameters *bin_array_parameters_pt)
Constructor.
Vector< Vector< std::pair< FiniteElement *, Vector< double > > > > bin_content() const
Get the contents of all bins in vector.
double min_distance(const unsigned &i_bin, const Vector< double > &zeta)
Compute the minimum distance of any vertex in the specified bin from the specified Lagrangian coordin...
unsigned nbin() const
Total number of bins (empty or not)
unsigned & current_max_spiral_level()
Access function to current max. spiral level.
///////////////////////////////////////////////////////////////////// ///////////////////////////////...
unsigned & total_number_of_sample_points_visited_during_locate_zeta_from_top_level()
Counter to keep track of how many sample points we've visited during top level call to locate_zeta.
unsigned Multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta
Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic o...
unsigned depth() const
Depth of the hierarchical bin_array.
Vector< RefineableBin * > Bin_pt
Vector of pointers to constituent RefineableBins.
unsigned max_depth() const
Max depth of the hierarchical bin_array; const version.
unsigned Max_depth
Max depth of the hierarchical bin_array.
unsigned & multiplier_for_max_sample_point_to_actually_lookup_during_locate_zeta()
Every time we've completed a "spiral", visiting a finite number of sample points in a deterministic o...
unsigned total_number_of_sample_points_computed_recursively() const
Compute total number of sample points recursively.
unsigned First_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
void fill_bin_array(const Vector< SamplePoint * > &sample_point_pt)
Fill the bin array with specified SamplePoints.
bool bin_array_is_recursive() const
Is the BinArray recursive?
static unsigned Default_n_bin_1d
Default number of bins (in each coordinate direction) (Note: don't move this into a common base class...
void operator=(const RefineableBinArray &)=delete
Broken assignment operator.
void add_sample_point(SamplePoint *new_sample_point_pt, const Vector< double > &zeta)
Add specified SamplePoint to RefineableBinArray.
unsigned & last_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
void 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 gl...
unsigned nbin() const
Number of bins (not taking recursion into account)
RefineableBinArray * Root_bin_array_pt
Pointer to root bin array.
unsigned Depth
Variable which stores the Depth value of the bin_array. Useful for debugging and for preventing "infi...
RefineableBinArray * root_bin_array_pt() const
Root bin array.
unsigned Max_number_of_sample_point_per_bin
Maximum number of sample points in bin (before it's subdivided recursively)
void fill_bin_array()
Fill the bin array with sample points from FiniteElements stored in mesh.
void output_bin_vertices(std::ofstream &outfile)
Output bin vertices (allowing display of bins as zones).
void output_neighbouring_bins(const unsigned &bin_index, const unsigned &radius, std::ofstream &outfile)
Output neighbouring bins at given "radius" of the specified bin.
unsigned Last_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
RefineableBin * bin_pt(const unsigned &i) const
Pointer to i-th bin; can be null if bin is empty.
void get_bin_boundaries(const unsigned &bin_index, Vector< std::pair< double, double > > &min_and_max_coordinates)
Boundaries of specified bin in each coordinate direction. *.first = min; *.second = max.
void output_bins(std::ofstream &outfile)
Output bins.
void create_sample_points_from_element(FiniteElement *const element_pt, const unsigned &n_element)
Loop over all sample points in the element specified via the pointer and create a SamplePoint for eac...
unsigned Initial_last_sample_point_to_actually_lookup_during_locate_zeta
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
RefineableBinArray(SamplePointContainerParameters *bin_array_parameters_pt)
Constructor.
unsigned max_number_of_sample_point_per_bin() const
Maximum number of sample points in bin (before its subdivided recursively)
unsigned & initial_last_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
RefineableBinArray(const RefineableBinArray &data)=delete
Broken copy constructor.
unsigned & first_sample_point_to_actually_lookup_during_locate_zeta()
When searching through sample points recursively from the top level RefineableBinArray (in determinis...
unsigned & max_depth()
Max depth of the hierarchical bin_array.
bool Bin_array_is_recursive
Variable which stores if the RefineableBinArray is recursive or not.
RefineableBin class. Contains sample points and is embedded in a RefineableBinArray....
void output_bins(std::ofstream &outfile)
Output bin vertices (allowing display of bins as zones).
unsigned nsample_points_in_bin()
Number of sample points stored in bin.
void make_sub_bin_array(const Vector< std::pair< double, double > > &min_and_max_coordinates)
Method for building a new subbin_array (called when the Bin size is greater than the Max_number_of_sa...
void get_bin_boundaries(Vector< std::pair< double, double > > &min_and_max_coordinates)
Boundaries of bin in each coordinate direction. *.first = min; *.second = max.
void output(std::ofstream &outfile, const bool &don_t_recurse=false)
Output bin; x,[y,[z]],n_sample_points.
void add_sample_point(SamplePoint *new_sample_point_pt, const Vector< double > &zeta_coordinates)
Add a new sample point to RefineableBin.
RefineableBinArray * Sub_bin_array_pt
Pointer to a possible sub-BinArray. Null by default.
void output_bin_vertices(std::ofstream &outfile)
Output bin vertices (allowing display of bins as zones).
unsigned total_number_of_sample_points_computed_recursively() const
Compute total number of sample points recursively.
unsigned Bin_index_in_bin_array
Index of bin in its bin array.
~RefineableBin()
Destructor.
void 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 gl...
Vector< SamplePoint * > * Sample_point_pt
Container of SamplePoints. Pointer to vector because it's shorter than an empty vector!...
void operator=(const RefineableBin &)=delete
Broken assignment operator.
RefineableBin(RefineableBinArray *bin_array_pt, const unsigned &bin_index_in_bin_array)
Constructor. Pass pointer to bin array that contains this bin and the index of the newly created bin ...
RefineableBinArray * Bin_array_pt
Pointer to the bin array which "owns" this RefineableBin.
RefineableBin(const RefineableBin &data)=delete
Broken copy constructor.
///////////////////////////////////////////////////////////////////// ///////////////////////////////...
static bool Always_fail_elemental_locate_zeta
Boolean flag to make to make locate zeta fail. Used for debugging/ illustration of search procedures.
static double Percentage_offset
Offset of sample point container boundaries beyond max/min coords.
Vector< std::pair< double, double > > Min_and_max_coordinates
Vector of pairs of doubles for min and maximum coordinates. Call: Min_and_max_coordinates[j] gives me...
virtual unsigned & total_number_of_sample_points_visited_during_locate_zeta_from_top_level()
Counter to keep track of how many sample points we've visited during top level call to locate_zeta....
static bool Enable_timing_of_setup
Time setup?
bool ignore_halo_elements_during_locate_zeta_search() const
Ignore halo elements?
bool Ignore_halo_elements_during_locate_zeta_search
Ignore halo elements?
SamplePointContainer()
Broken default constructor; needed for broken copy constructors. Don't call. It will die.
SamplePointContainer(Mesh *mesh_pt, const Vector< std::pair< double, double > > &min_and_max_coordinates, const bool &use_eulerian_coordinates_during_setup, const bool &ignore_halo_elements_during_locate_zeta_search, const unsigned &nsample_points_generated_per_element)
Constructor.
bool use_eulerian_coordinates_during_setup() const
Use Eulerian coordinates (i.e. interpolated_x) rather than zeta itself (i.e. interpolated_zeta) to id...
SamplePointContainer(const SamplePointContainer &data)=delete
Broken copy constructor.
virtual ~SamplePointContainer()
Virtual destructor.
unsigned & nsample_points_generated_per_element()
"Measure of" number of sample points generated in each element
unsigned Nsample_points_generated_per_element
"Measure of" number of sample points generated in each element
unsigned Total_number_of_sample_points_visited_during_locate_zeta_from_top_level
Counter to keep track of how many sample points we've visited during top level call to locate_zeta.
bool Use_eulerian_coordinates_during_setup
Use Eulerian coordinates (i.e. interpolated_x) rather than zeta itself (i.e. interpolated_zeta) to id...
Mesh * Mesh_pt
Pointer to mesh from whose FiniteElements sample points are created.
const Vector< std::pair< double, double > > & min_and_max_coordinates() const
Vector of pair of doubles for min and maximum coordinates. min (first) and max. (second) coordinates.
Mesh * mesh_pt() const
Pointer to mesh from whose FiniteElements sample points are created.
const std::pair< double, double > & min_and_max_coordinates(const unsigned &i) const
Pair of doubles for min and maximum coordinates in i-th direction: min (first) and max....
double Max_search_radius
Max radius beyond which we stop searching the bin. Initialised to DBL_MAX so keep going until the poi...
double & max_search_radius()
Set maximum search radius for locate zeta. This is initialised do DBL_MAX so we brutally search throu...
virtual unsigned total_number_of_sample_points_computed_recursively() const =0
Total number of sample points in sample point container, possibly computed recursively.
virtual void locate_zeta(const Vector< double > &zeta, GeomObject *&sub_geom_object_pt, Vector< double > &s)=0
Find sub-GeomObject (finite element) and the local coordinate s within it that contains point with gl...
static std::ofstream Visited_sample_points_file
File to record sequence of visited sample points in. Used for debugging/ illustration of search proce...
void operator=(const SamplePointContainer &)=delete
Broken assignment operator.
virtual unsigned ndim_zeta() const =0
Dimension of the zeta ( = dim of local coordinate of elements)
void setup_min_and_max_coordinates()
Helper function to compute the min and max coordinates for the mesh, in each dimension.
static bool Use_equally_spaced_interior_sample_points
Use equally spaced sample points? (otherwise vertices are sampled repeatedly.
///////////////////////////////////////////////////////////////// ///////////////////////////////////...
SamplePoint(const unsigned &element_index_in_mesh, const unsigned &sample_point_index_in_element)
Construct SamplePoint object from number of finite element in its mesh, and index of sample point wit...
void operator=(const SamplePoint &)=delete
Broken assignment operator.
SamplePoint(const SamplePoint &data)=delete
Broken copy constructor.
unsigned element_index_in_mesh() const
Access function to the index of finite element in its mesh.
unsigned Sample_point_index_in_element
Index of the sample point within element.
unsigned Element_index_in_mesh
Index of finite element in its mesh.
unsigned sample_point_index_in_element() const
Index of sample point within element.
std::string string(const unsigned &i)
Return the i-th string or "" if the relevant string hasn't been defined.