SheafSystem  0.0.0.0
d_array_point_locator.cc
Go to the documentation of this file.
1 
2 //
3 // Copyright (c) 2014 Limit Point Systems, Inc.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 
20 
21 
22 #include "SheafSystem/d_array_point_locator.impl.h"
23 
24 using namespace std;
25 using namespace geometry; // Workaround for MS C++ bug.
26 
27 // ============================================================================
29 // ============================================================================
31 
32 template <>
33 void
34 geometry::d_array_point_locator<1, 1>::
35 insert_box(d_bounding_box<1, 1>* xbox)
36 {
37  // Preconditions:
38 
39  require(xbox != 0);
40 
41  // Body:
42 
43  define_old_variable(size_type old_box_ct = _box_ct);
44 
45  size_type ilb = xbox->lb()[0];
46  size_type iub = xbox->ub()[0];
47 
48  for(size_type i=ilb; i<=iub; ++i)
49  {
50  _bins[i].push_front(xbox);
51  }
52 
53  _box_ct++;
54 
55 
56  // Postconditions:
57 
58  ensure(contains_box(xbox));
59  ensure(box_ct() == old_box_ct + 1);
60 
61  // Exit:
62 
63  return;
64 }
65 
66 template <>
67 void
68 geometry::d_array_point_locator<2, 2>::
69 insert_box(d_bounding_box<2, 2>* xbox)
70 {
71  // Preconditions:
72 
73  require(xbox != 0);
74 
75  // Body:
76 
77  define_old_variable(size_type old_box_ct = _box_ct);
78 
79  size_type ilb = xbox->lb()[0];
80  size_type jlb = xbox->lb()[1];
81  size_type iub = xbox->ub()[0];
82  size_type jub = xbox->ub()[1];
83 
84  for(size_type i=ilb; i<=iub; ++i)
85  {
86  for(size_type j=jlb; j<=jub; ++j)
87  {
88  _bins[bin_id(i, j)].push_front(xbox);
89  }
90  }
91 
92  _box_ct++;
93 
94 
95  // Postconditions:
96 
97  ensure(contains_box(xbox));
98  ensure(box_ct() == old_box_ct + 1);
99 
100  // Exit:
101 
102  return;
103 }
104 
105 template <>
106 void
107 geometry::d_array_point_locator<3, 1>::
108 insert_box(d_bounding_box<3, 1>* xbox)
109 {
110  // Preconditions:
111 
112  require(xbox != 0);
113 
114  // Body:
115 
116  define_old_variable(size_type old_box_ct = _box_ct);
117 
118  size_type ilb = xbox->lb()[0];
119  size_type jlb = xbox->lb()[1];
120  size_type klb = xbox->lb()[2];
121  size_type iub = xbox->ub()[0];
122  size_type jub = xbox->ub()[1];
123  size_type kub = xbox->ub()[2];
124 
125  for(size_type i=ilb; i<=iub; ++i)
126  {
127  for(size_type j=jlb; j<=jub; ++j)
128  {
129  for(size_type k=klb; k<=kub; ++k)
130  {
131  _bins[bin_id(i, j, k)].push_front(xbox);
132  }
133  }
134  }
135 
136  _box_ct++;
137 
138 
139  // Postconditions:
140 
141  ensure(contains_box(xbox));
142  ensure(box_ct() == old_box_ct + 1);
143 
144  // Exit:
145 
146  return;
147 }
148 
149 template <>
150 void
151 geometry::d_array_point_locator<3, 2>::
152 insert_box(d_bounding_box<3, 2>* xbox)
153 {
154  // Preconditions:
155 
156  require(xbox != 0);
157 
158  // Body:
159 
160  define_old_variable(size_type old_box_ct = _box_ct);
161 
162  size_type ilb = xbox->lb()[0];
163  size_type jlb = xbox->lb()[1];
164  size_type klb = xbox->lb()[2];
165  size_type iub = xbox->ub()[0];
166  size_type jub = xbox->ub()[1];
167  size_type kub = xbox->ub()[2];
168 
169  for(size_type i=ilb; i<=iub; ++i)
170  {
171  for(size_type j=jlb; j<=jub; ++j)
172  {
173  for(size_type k=klb; k<=kub; ++k)
174  {
175  _bins[bin_id(i, j, k)].push_front(xbox);
176  }
177  }
178  }
179 
180  _box_ct++;
181 
182 
183  // Postconditions:
184 
185  ensure(contains_box(xbox));
186  ensure(box_ct() == old_box_ct + 1);
187 
188  // Exit:
189 
190  return;
191 }
192 
193 template <>
194 void
195 geometry::d_array_point_locator<3, 3>::
196 insert_box(d_bounding_box<3, 3>* xbox)
197 {
198  // Preconditions:
199 
200  require(xbox != 0);
201 
202  // Body:
203 
204  define_old_variable(size_type old_box_ct = _box_ct);
205 
206  size_type ilb = xbox->lb()[0];
207  size_type jlb = xbox->lb()[1];
208  size_type klb = xbox->lb()[2];
209  size_type iub = xbox->ub()[0];
210  size_type jub = xbox->ub()[1];
211  size_type kub = xbox->ub()[2];
212 
213  for(size_type i=ilb; i<=iub; ++i)
214  {
215  for(size_type j=jlb; j<=jub; ++j)
216  {
217  for(size_type k=klb; k<=kub; ++k)
218  {
219  _bins[bin_id(i, j, k)].push_front(xbox);
220  }
221  }
222  }
223 
224  _box_ct++;
225 
226 
227  // Postconditions:
228 
229  ensure(contains_box(xbox));
230  ensure(box_ct() == old_box_ct + 1);
231 
232  // Exit:
233 
234  return;
235 }
236 
237 template <>
238 void
239 geometry::d_array_point_locator<1, 1>::
240 box_list(const section_evaluator& xeval,
241  sec_vd_value_type* xdofs,
242  size_type xdofs_ub,
243  box_list_type& xresult) const
244 {
245  const int DC = 1;
246  const int DB = 1;
247 
248  // Preconditions:
249 
250  require(xdofs != 0);
251  require(xdofs_ub >= DC*xeval.dof_ct());
252  require(unexecutable("this->domain_contains(xeval, xdofs)"));
253 
254  // Body:
255 
256  // Get the bounds for this eval member.
257  // Must convert from the global coordinate system to search
258  // structure-relative coordinates.
259 
260  sec_vd_value_type gbl_pos[DC];
261 
262  xeval.min(xdofs, xdofs_ub, gbl_pos, DC);
263  d_bin_coordinates<DC, DB> llb;
264  this->relative_position_pa(gbl_pos, DC, llb);
265 
266  xeval.max(xdofs, xdofs_ub, gbl_pos, DC);
267  d_bin_coordinates<DC, DB> lub;
268  this->relative_position_pa(gbl_pos, DC, lub);
269 
270  size_type ilb = llb[0];
271  size_type iub = lub[0];
272 
273  for(size_type i=ilb; i<=iub; ++i)
274  {
275  const box_list_type& lbox_list = _bins[i];
276  xresult.push_front(lbox_list.begin(), lbox_list.end());
277  }
278 
279  // Postconditions:
280 
281  // Exit:
282 
283  return;
284 }
285 
286 template <>
287 void
288 geometry::d_array_point_locator<2, 2>::
289 box_list(const section_evaluator& xeval,
290  sec_vd_value_type* xdofs,
291  size_type xdofs_ub,
292  box_list_type& xresult) const
293 {
294  const int DC = 2;
295  const int DB = 2;
296 
297  // Preconditions:
298 
299  require(xdofs != 0);
300  require(xdofs_ub >= DC*xeval.dof_ct());
301  require(unexecutable("this->domain_contains(xeval, xdofs)"));
302 
303  // Body:
304 
305  // Get the bounds for this eval member.
306  // Must convert from the global coordinate system to search
307  // structure-relative coordinates.
308 
309  sec_vd_value_type gbl_pos[DC];
310 
311  xeval.min(xdofs, xdofs_ub, gbl_pos, DC);
312  d_bin_coordinates<DC, DB> llb;
313  this->relative_position_pa(gbl_pos, DC, llb);
314 
315  xeval.max(xdofs, xdofs_ub, gbl_pos, DC);
316  d_bin_coordinates<DC, DB> lub;
317  this->relative_position_pa(gbl_pos, DC, lub);
318 
319  size_type ilb = llb[0];
320  size_type jlb = llb[1];
321  size_type iub = lub[0];
322  size_type jub = lub[1];
323 
324  for(size_type i=ilb; i<=iub; ++i)
325  {
326  for(size_type j=jlb; j<=jub; ++j)
327  {
328  const box_list_type& lbox_list = _bins[bin_id(i, j)];
329  xresult.push_front(lbox_list.begin(), lbox_list.end());
330  }
331  }
332 
333  // Postconditions:
334 
335  // Exit:
336 
337  return;
338 }
339 
340 template <>
341 void
342 geometry::d_array_point_locator<3, 1>::
343 box_list(const section_evaluator& xeval,
344  sec_vd_value_type* xdofs,
345  size_type xdofs_ub,
346  box_list_type& xresult) const
347 {
348  const int DC = 3;
349  const int DB = 1;
350 
351  // Preconditions:
352 
353  require(xdofs != 0);
354  require(xdofs_ub >= DC*xeval.dof_ct());
355  require(unexecutable("this->domain_contains(xeval, xdofs)"));
356 
357  // Body:
358 
359  // Get the bounds for this eval member.
360  // Must convert from the global coordinate system to search
361  // structure-relative coordinates.
362 
363  sec_vd_value_type gbl_pos[DC];
364 
365  xeval.min(xdofs, xdofs_ub, gbl_pos, DC);
366  d_bin_coordinates<DC, DB> llb;
367  this->relative_position_pa(gbl_pos, DC, llb);
368 
369  xeval.max(xdofs, xdofs_ub, gbl_pos, DC);
370  d_bin_coordinates<DC, DB> lub;
371  this->relative_position_pa(gbl_pos, DC, lub);
372 
373  size_type ilb = llb[0];
374  size_type jlb = llb[1];
375  size_type klb = llb[2];
376  size_type iub = lub[0];
377  size_type jub = lub[1];
378  size_type kub = lub[2];
379 
380  for(size_type i=ilb; i<=iub; ++i)
381  {
382  for(size_type j=jlb; j<=jub; ++j)
383  {
384  for(size_type k=klb; k<=kub; ++k)
385  {
386  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
387  xresult.push_front(lbox_list.begin(), lbox_list.end());
388  }
389  }
390  }
391 
392  // Postconditions:
393 
394  // Exit:
395 
396  return;
397 }
398 
399 template <>
400 void
401 geometry::d_array_point_locator<3, 2>::
402 box_list(const section_evaluator& xeval,
403  sec_vd_value_type* xdofs,
404  size_type xdofs_ub,
405  box_list_type& xresult) const
406 {
407  const int DC = 3;
408  const int DB = 2;
409 
410  // Preconditions:
411 
412  require(xdofs != 0);
413  require(xdofs_ub >= DC*xeval.dof_ct());
414  require(unexecutable("this->domain_contains(xeval, xdofs)"));
415 
416  // Body:
417 
418  // Get the bounds for this eval member.
419  // Must convert from the global coordinate system to search
420  // structure-relative coordinates.
421 
422  sec_vd_value_type gbl_pos[DC];
423 
424  xeval.min(xdofs, xdofs_ub, gbl_pos, DC);
425  d_bin_coordinates<DC, DB> llb;
426  this->relative_position_pa(gbl_pos, DC, llb);
427 
428  xeval.max(xdofs, xdofs_ub, gbl_pos, DC);
429  d_bin_coordinates<DC, DB> lub;
430  this->relative_position_pa(gbl_pos, DC, lub);
431 
432  size_type ilb = llb[0];
433  size_type jlb = llb[1];
434  size_type klb = llb[2];
435  size_type iub = lub[0];
436  size_type jub = lub[1];
437  size_type kub = lub[2];
438 
439  for(size_type i=ilb; i<=iub; ++i)
440  {
441  for(size_type j=jlb; j<=jub; ++j)
442  {
443  for(size_type k=klb; k<=kub; ++k)
444  {
445  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
446  xresult.push_front(lbox_list.begin(), lbox_list.end());
447  }
448  }
449  }
450 
451  // Postconditions:
452 
453  // Exit:
454 
455  return;
456 }
457 
458 template <>
459 void
460 geometry::d_array_point_locator<3, 3>::
461 box_list(const section_evaluator& xeval,
462  sec_vd_value_type* xdofs,
463  size_type xdofs_ub,
464  box_list_type& xresult) const
465 {
466  const int DC = 3;
467  const int DB = 3;
468 
469  // Preconditions:
470 
471  require(xdofs != 0);
472  require(xdofs_ub >= DC*xeval.dof_ct());
473  require(unexecutable("this->domain_contains(xeval, xdofs)"));
474 
475  // Body:
476 
477  // Get the bounds for this eval member.
478  // Must convert from the global coordinate system to search
479  // structure-relative coordinates.
480 
481  sec_vd_value_type gbl_pos[DC];
482 
483  xeval.min(xdofs, xdofs_ub, gbl_pos, DC);
484  d_bin_coordinates<DC, DB> llb;
485  this->relative_position_pa(gbl_pos, DC, llb);
486 
487  xeval.max(xdofs, xdofs_ub, gbl_pos, DC);
488  d_bin_coordinates<DC, DB> lub;
489  this->relative_position_pa(gbl_pos, DC, lub);
490 
491 
492  size_type ilb = llb[0];
493  size_type jlb = llb[1];
494  size_type klb = llb[2];
495  size_type iub = lub[0];
496  size_type jub = lub[1];
497  size_type kub = lub[2];
498 
499  for(size_type i=ilb; i<=iub; ++i)
500  {
501  for(size_type j=jlb; j<=jub; ++j)
502  {
503  for(size_type k=klb; k<=kub; ++k)
504  {
505  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
506  xresult.push_front(lbox_list.begin(), lbox_list.end());
507  }
508  }
509  }
510 
511  // Postconditions:
512 
513  // Exit:
514 
515  return;
516 }
517 
518 template <>
519 void
520 geometry::d_array_point_locator<1, 1>::
521 box_list(d_bounding_box<1, 1>* xbox, box_set_type& xresult) const
522 {
523  const int DC = 1;
524  const int DB = 1;
525 
526  // Preconditions:
527 
528 
529  // Body:
530 
531  size_type ilb = xbox->lb()[0];
532  size_type iub = xbox->ub()[0];
533 
534  for(size_type i=ilb; i<=iub; ++i)
535  {
536  const box_list_type& lbox_list = _bins[i];
537  xresult.insert(lbox_list.begin(), lbox_list.end());
538  }
539 
540  // Postconditions:
541 
542  // Exit:
543 
544  return;
545 }
546 
547 template <>
548 void
549 geometry::d_array_point_locator<2, 2>::
550 box_list(d_bounding_box<2, 2>* xbox, box_set_type& xresult) const
551 {
552  // Preconditions:
553 
554 
555  // Body:
556 
557  size_type ilb = xbox->lb()[0];
558  size_type jlb = xbox->lb()[1];
559  size_type iub = xbox->ub()[0];
560  size_type jub = xbox->ub()[1];
561 
562  for(size_type i=ilb; i<=iub; ++i)
563  {
564  for(size_type j=jlb; j<=jub; ++j)
565  {
566  const box_list_type& lbox_list = _bins[bin_id(i, j)];
567  xresult.insert(lbox_list.begin(), lbox_list.end());
568  }
569  }
570 
571  // Postconditions:
572 
573  // Exit:
574 
575  return;
576 }
577 
578 template <>
579 void
580 geometry::d_array_point_locator<3, 1>::
581 box_list(d_bounding_box<3, 1>* xbox, box_set_type& xresult) const
582 {
583  // Preconditions:
584 
585 
586  // Body:
587 
588  size_type ilb = xbox->lb()[0];
589  size_type jlb = xbox->lb()[1];
590  size_type klb = xbox->lb()[2];
591  size_type iub = xbox->ub()[0];
592  size_type jub = xbox->ub()[1];
593  size_type kub = xbox->ub()[2];
594 
595  for(size_type i=ilb; i<=iub; ++i)
596  {
597  for(size_type j=jlb; j<=jub; ++j)
598  {
599  for(size_type k=klb; k<=kub; ++k)
600  {
601  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
602  xresult.insert(lbox_list.begin(), lbox_list.end());
603  }
604  }
605  }
606 
607  // Postconditions:
608 
609  // Exit:
610 
611  return;
612 }
613 
614 template <>
615 void
616 geometry::d_array_point_locator<3, 2>::
617 box_list(d_bounding_box<3, 2>* xbox, box_set_type& xresult) const
618 {
619  // Preconditions:
620 
621 
622  // Body:
623 
624  size_type ilb = xbox->lb()[0];
625  size_type jlb = xbox->lb()[1];
626  size_type klb = xbox->lb()[2];
627  size_type iub = xbox->ub()[0];
628  size_type jub = xbox->ub()[1];
629  size_type kub = xbox->ub()[2];
630 
631  for(size_type i=ilb; i<=iub; ++i)
632  {
633  for(size_type j=jlb; j<=jub; ++j)
634  {
635  for(size_type k=klb; k<=kub; ++k)
636  {
637  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
638  xresult.insert(lbox_list.begin(), lbox_list.end());
639  }
640  }
641  }
642 
643  // Postconditions:
644 
645  // Exit:
646 
647  return;
648 }
649 
650 template <>
651 void
652 geometry::d_array_point_locator<3, 3>::
653 box_list(d_bounding_box<3, 3>* xbox, box_set_type& xresult) const
654 {
655  // Preconditions:
656 
657 
658  // Body:
659 
660  size_type ilb = xbox->lb()[0];
661  size_type jlb = xbox->lb()[1];
662  size_type klb = xbox->lb()[2];
663  size_type iub = xbox->ub()[0];
664  size_type jub = xbox->ub()[1];
665  size_type kub = xbox->ub()[2];
666 
667  for(size_type i=ilb; i<=iub; ++i)
668  {
669  for(size_type j=jlb; j<=jub; ++j)
670  {
671  for(size_type k=klb; k<=kub; ++k)
672  {
673  const box_list_type& lbox_list = _bins[bin_id(i, j, k)];
674  xresult.insert(lbox_list.begin(), lbox_list.end());
675  }
676  }
677  }
678 
679  // Postconditions:
680 
681  // Exit:
682 
683  return;
684 }
685 
686 template <>
687 void
688 geometry::d_array_point_locator<1, 1>::
689 remove_box(d_bounding_box<1, 1>* xbox)
690 {
691  // Preconditions:
692 
693  require(xbox != 0);
694  require(contains_box(xbox));
695 
696  // Body:
697 
698  define_old_variable(size_type old_box_ct = _box_ct);
699 
700  size_type ilb = xbox->lb()[0];
701  size_type iub = xbox->ub()[0];
702 
703  for(size_type i=ilb; i<=iub; ++i)
704  {
705  _bins[i].remove(xbox);
706  }
707 
708  _box_ct--;
709 
710  // Postconditions:
711 
712  ensure(!contains_box(xbox));
713  ensure(box_ct() == old_box_ct - 1);
714 
715  // Exit:
716 
717  return;
718 }
719 
720 template <>
721 void
722 geometry::d_array_point_locator<2, 2>::
723 remove_box(d_bounding_box<2, 2>* xbox)
724 {
725  // Preconditions:
726 
727  require(xbox != 0);
728  require(contains_box(xbox));
729 
730  // Body:
731 
732  define_old_variable(size_type old_box_ct = _box_ct);
733 
734  size_type ilb = xbox->lb()[0];
735  size_type jlb = xbox->lb()[1];
736  size_type iub = xbox->ub()[0];
737  size_type jub = xbox->ub()[1];
738 
739  for(size_type i=ilb; i<=iub; ++i)
740  {
741  for(size_type j=jlb; j<=jub; ++j)
742  {
743  _bins[bin_id(i, j)].remove(xbox);
744  }
745  }
746 
747  _box_ct--;
748 
749  // Postconditions:
750 
751  ensure(!contains_box(xbox));
752  ensure(box_ct() == old_box_ct - 1);
753 
754  // Exit:
755 
756  return;
757 }
758 
759 template <>
760 void
761 geometry::d_array_point_locator<3, 1>::
762 remove_box(d_bounding_box<3, 1>* xbox)
763 {
764  // Preconditions:
765 
766  require(xbox != 0);
767  require(contains_box(xbox));
768 
769  // Body:
770 
771  define_old_variable(size_type old_box_ct = _box_ct);
772 
773  size_type ilb = xbox->lb()[0];
774  size_type jlb = xbox->lb()[1];
775  size_type klb = xbox->lb()[2];
776  size_type iub = xbox->ub()[0];
777  size_type jub = xbox->ub()[1];
778  size_type kub = xbox->ub()[2];
779 
780  for(size_type i=ilb; i<=iub; ++i)
781  {
782  for(size_type j=jlb; j<=jub; ++j)
783  {
784  for(size_type k=klb; k<=kub; ++k)
785  {
786  _bins[bin_id(i, j, k)].remove(xbox);
787  }
788  }
789  }
790 
791  _box_ct--;
792 
793  // Postconditions:
794 
795  ensure(!contains_box(xbox));
796  ensure(box_ct() == old_box_ct - 1);
797 
798  // Exit:
799 
800  return;
801 }
802 
803 template <>
804 void
805 geometry::d_array_point_locator<3, 2>::
806 remove_box(d_bounding_box<3, 2>* xbox)
807 {
808  // Preconditions:
809 
810  require(xbox != 0);
811  require(contains_box(xbox));
812 
813  // Body:
814 
815  define_old_variable(size_type old_box_ct = _box_ct);
816 
817  size_type ilb = xbox->lb()[0];
818  size_type jlb = xbox->lb()[1];
819  size_type klb = xbox->lb()[2];
820  size_type iub = xbox->ub()[0];
821  size_type jub = xbox->ub()[1];
822  size_type kub = xbox->ub()[2];
823 
824  for(size_type i=ilb; i<=iub; ++i)
825  {
826  for(size_type j=jlb; j<=jub; ++j)
827  {
828  for(size_type k=klb; k<=kub; ++k)
829  {
830  _bins[bin_id(i, j, k)].remove(xbox);
831  }
832  }
833  }
834 
835  _box_ct--;
836 
837  // Postconditions:
838 
839  ensure(!contains_box(xbox));
840  ensure(box_ct() == old_box_ct - 1);
841 
842  // Exit:
843 
844  return;
845 }
846 
847 template <>
848 void
849 geometry::d_array_point_locator<3, 3>::
850 remove_box(d_bounding_box<3, 3>* xbox)
851 {
852  // Preconditions:
853 
854  require(xbox != 0);
855  require(contains_box(xbox));
856 
857  // Body:
858 
859  define_old_variable(size_type old_box_ct = _box_ct);
860 
861  size_type ilb = xbox->lb()[0];
862  size_type jlb = xbox->lb()[1];
863  size_type klb = xbox->lb()[2];
864  size_type iub = xbox->ub()[0];
865  size_type jub = xbox->ub()[1];
866  size_type kub = xbox->ub()[2];
867 
868  for(size_type i=ilb; i<=iub; ++i)
869  {
870  for(size_type j=jlb; j<=jub; ++j)
871  {
872  for(size_type k=klb; k<=kub; ++k)
873  {
874  _bins[bin_id(i, j, k)].remove(xbox);
875  }
876  }
877  }
878 
879  _box_ct--;
880 
881  // Postconditions:
882 
883  ensure(!contains_box(xbox));
884  ensure(box_ct() == old_box_ct - 1);
885 
886  // Exit:
887 
888  return;
889 }
890 
891 //==============================================================================
892 // SPECIALIZATIONS
893 //==============================================================================
894 
895 template <>
896 size_type
897 d_array_point_locator<1, 1>::
898 bin_id(const d_bin_coordinates<1, 1>& xcoord) const
899 {
900  return xcoord[0];
901 };
902 
903 template <>
904 size_type
905 d_array_point_locator<2, 2>::
906 bin_id(const d_bin_coordinates<2, 2>& xcoord) const
907 {
908  return (xcoord[0]*_bin_ub[1] + xcoord[1]);
909 };
910 
911 template <>
912 size_type
913 d_array_point_locator<3, 1>::
914 bin_id(const d_bin_coordinates<3, 1>& xcoord) const
915 {
916  return (xcoord[0]*_bin_ub[1] + xcoord[1])*_bin_ub[2] + xcoord[2];
917 };
918 
919 template <>
920 size_type
921 d_array_point_locator<3, 2>::
922 bin_id(const d_bin_coordinates<3, 2>& xcoord) const
923 {
924  return (xcoord[0]*_bin_ub[1] + xcoord[1])*_bin_ub[2] + xcoord[2];
925 };
926 
927 template <>
928 size_type
929 d_array_point_locator<3, 3>::
930 bin_id(const d_bin_coordinates<3, 3>& xcoord) const
931 {
932  return (xcoord[0]*_bin_ub[1] + xcoord[1])*_bin_ub[2] + xcoord[2];
933 };
934 
935 template <>
936 size_type
937 d_array_point_locator<1, 1>::
938 bin_id(const block<size_type>& xid) const
939 {
940  return xid[0];
941 };
942 
943 template <>
944 size_type
945 d_array_point_locator<2, 2>::
946 bin_id(const block<size_type>& xid) const
947 {
948  return (xid[0]*_bin_ub[1] + xid[1]);
949 };
950 
951 template <>
952 size_type
953 d_array_point_locator<3, 1>::
954 bin_id(const block<size_type>& xid) const
955 {
956  return (xid[0]*_bin_ub[1] + xid[1])*_bin_ub[2] + xid[2];
957 };
958 
959 template <>
960 size_type
961 d_array_point_locator<3, 2>::
962 bin_id(const block<size_type>& xid) const
963 {
964  return (xid[0]*_bin_ub[1] + xid[1])*_bin_ub[2] + xid[2];
965 };
966 
967 template <>
968 size_type
969 d_array_point_locator<3, 3>::
970 bin_id(const block<size_type>& xid) const
971 {
972  return (xid[0]*_bin_ub[1] + xid[1])*_bin_ub[2] + xid[2];
973 };
974 
975 
std
STL namespace.
geometry::d_bounding_box::ub
const d_bin_coordinates< DC, DB > & ub() const
The upper bound; the upper, right, rear corner.
Definition: d_bounding_box.impl.h:254
sheaf::singly_linked_list::begin
iterator begin()
Returns an iterator to the first element of the container.
Definition: singly_linked_list.h:184
geometry::d_bin_coordinates
Fixed point relative coordinates for a tree domain.
Definition: cylindrical_point_locator.h:65
geometry::d_array_point_locator::insert_box
virtual void insert_box(d_bounding_box< DC, DB > *xbox)
Insert xbox into this.
fiber_bundle::section_evaluator::max
virtual dof_type max(const dof_type xdofs[], size_type xdofs_ub) const
The maximum value of the scalar or component section defined by xdofs.
Definition: section_evaluator.cc:608
fiber_bundle::section_evaluator::dof_ct
virtual size_type dof_ct() const =0
The number of dofs required for each component of the dependent variable.
Definition: section_evaluator.cc:264
geometry::d_bounding_box::lb
const d_bin_coordinates< DC, DB > & lb() const
The lower bound; the lower, left, front corner.
Definition: d_bounding_box.impl.h:226
sheaf::size_type
unsigned long size_type
An unsigned integral type used to represent sizes and capacities.
Definition: sheaf.h:52
geometry::d_bounding_box
A bounding box that can be strung together into a list.
Definition: array_cylindrical_point_locator.h:36
sheaf::singly_linked_list::end
iterator end()
Returns an iterator to the element following the last element of the container.
Definition: singly_linked_list.h:201
fiber_bundle::section_evaluator
An abstract local section evaluator; a map from {local coordinates x dofs} to section value...
Definition: section_evaluator.h:53
geometry::d_array_point_locator::box_list
virtual const box_list_type & box_list(sec_vd_value_type *xpt, size_type xpt_ub) const
The list of bounding boxes which may contain xpt.
Definition: d_array_point_locator.impl.h:48
fiber_bundle::section_evaluator::min
virtual dof_type min(const dof_type xdofs[], size_type xdofs_ub) const
The minimum value of the scalar or component section defined by xdofs.
Definition: section_evaluator.cc:494
sheaf::singly_linked_list::push_front
void push_front(const T &value)
Prepends the given element value to the beginning of the container.
Definition: singly_linked_list.h:348
geometry::d_array_point_locator::box_set_type
std::set< const d_bounding_box< DC, DB > * > box_set_type
The type of box set.
Definition: d_array_point_locator.h:63
geometry::d_array_point_locator::remove_box
virtual void remove_box(d_bounding_box< DC, DB > *xbox)
Remove xbox from this.
geometry
Namespace for geometry component of sheaf system.
Definition: field_vd.h:54
fiber_bundle::sec_vd_value_type
vd_value_type sec_vd_value_type
The type of component in the value of a section at a point.
Definition: fiber_bundle.h:73
sheaf::singly_linked_list
Wrapper class for forward_list or slist depending on compiler. The class replicates the minimum subse...
Definition: singly_linked_list.h:42
geometry::d_array_point_locator
A point location query in domains with global coordinate dimension DC and local coordinate dimension ...
Definition: d_array_point_locator.h:45