Line data Source code
1 : #ifndef AMREX_INTERPOLATER_H_
2 : #define AMREX_INTERPOLATER_H_
3 : #include <AMReX_Config.H>
4 :
5 : #include <AMReX_Extension.H>
6 : #include <AMReX_GpuControl.H>
7 : #include <AMReX_InterpBase.H>
8 :
9 : namespace amrex {
10 :
11 : class Geometry;
12 : class FArrayBox;
13 : class IArrayBox;
14 :
15 : /**
16 : * \brief Virtual base class for interpolaters.
17 : *
18 : * Specifies interpolater interface for coarse-to-fine interpolation in space.
19 : */
20 : class Interpolater
21 : : public InterpBase
22 : {
23 : public:
24 : /**
25 : * \brief Coarse to fine interpolation in space.
26 : * This is a pure virtual function and hence MUST
27 : * be implemented by derived classes.
28 : *
29 : * \param crse
30 : * \param crse_comp
31 : * \param fine
32 : * \param fine_comp
33 : * \param ncomp
34 : * \param fine_region
35 : * \param ratio
36 : * \param crse_geom
37 : * \param fine_geom
38 : * \param bcr
39 : * \param actual_comp
40 : * \param actual_state
41 : */
42 : virtual void interp (const FArrayBox& crse,
43 : int crse_comp,
44 : FArrayBox& fine,
45 : int fine_comp,
46 : int ncomp,
47 : const Box& fine_region,
48 : const IntVect& ratio,
49 : const Geometry& crse_geom,
50 : const Geometry& fine_geom,
51 : Vector<BCRec> const & bcr,
52 : int actual_comp,
53 : int actual_state,
54 : RunOn runon) = 0;
55 :
56 : /**
57 : * \brief Coarse to fine interpolation in space for face-based data.
58 : *
59 : * \param crse
60 : * \param crse_comp
61 : * \param fine
62 : * \param fine_comp
63 : * \param ncomp
64 : * \param fine_region
65 : * \param fine_values
66 : * \param fine_known
67 : * \param ratio
68 : * \param crse_geom
69 : * \param fine_geom
70 : * \param bcr
71 : * \param bccomp
72 : * \param runon
73 : */
74 0 : virtual void interp_face (const FArrayBox& /*crse*/,
75 : const int /*crse_comp*/,
76 : FArrayBox& /*fine*/,
77 : const int /*fine_comp*/,
78 : const int /*ncomp*/,
79 : const Box& /*fine_region*/,
80 : const IntVect& /*ratio*/,
81 : const IArrayBox& /*solve_mask*/,
82 : const Geometry& /*crse_geom*/,
83 : const Geometry& /*fine_geom*/,
84 : Vector<BCRec> const & /*bcr*/,
85 : const int /*bccomp*/,
86 : RunOn /*runon*/)
87 0 : { amrex::Abort("The version of this Interpolater for face-based data is not implemented or does not apply. Call 'interp' instead."); }
88 :
89 : /**
90 : * \brief Coarse to fine interpolation in space.
91 : * Takes an Array of FArrayBox*s
92 : *
93 : * \param crse
94 : * \param crse_comp
95 : * \param fine
96 : * \param fine_comp
97 : * \param ncomp
98 : * \param fine_region
99 : * \param fine_values
100 : * \param fine_known
101 : * \param ratio
102 : * \param crse_geom
103 : * \param fine_geom
104 : * \param bcr
105 : * \param actual_comp
106 : * \param actual_state
107 : */
108 0 : virtual void interp_arr (Array<FArrayBox*, AMREX_SPACEDIM> const& /*crse*/,
109 : const int /*crse_comp*/,
110 : Array<FArrayBox*, AMREX_SPACEDIM> const& /*fine*/,
111 : const int /*fine_comp*/,
112 : const int /*ncomp*/,
113 : const Box& /*fine_region*/,
114 : const IntVect& /*ratio*/,
115 : Array<IArrayBox*, AMREX_SPACEDIM> const& /*solve_mask*/,
116 : const Geometry& /*crse_geom*/,
117 : const Geometry& /*fine_geom*/,
118 : Vector<Array<BCRec, AMREX_SPACEDIM> > const& /*bcr*/,
119 : const int /*actual_comp*/,
120 : const int /*actual_state*/,
121 : const RunOn /*runon*/)
122 :
123 0 : { amrex::Abort("The Array<FArrayBox*, AMREX_SPACEDIM> version of this Interpolater is not implemented or does not apply. Call 'interp' instead."); }
124 :
125 : /**
126 : * \brief Re-visit the interpolation to protect against under- or overshoots.
127 : *
128 : * \param crse
129 : * \param crse_comp
130 : * \param fine
131 : * \param fine_comp
132 : * \param fine_state
133 : * \param state_comp
134 : * \param ncomp
135 : * \param fine_region
136 : * \param ratio
137 : * \param crse_geom
138 : * \param fine_geom
139 : * \param bcr
140 : */
141 0 : virtual void protect (const FArrayBox& /*crse*/,
142 : int /*crse_comp*/,
143 : FArrayBox& /*fine*/,
144 : int /*fine_comp*/,
145 : FArrayBox& /*fine_state*/,
146 : int /*state_comp*/,
147 : int /*ncomp*/,
148 : const Box& /*fine_region*/,
149 : const IntVect& /*ratio*/,
150 : const Geometry& /*crse_geom*/,
151 : const Geometry& /*fine_geom*/,
152 : Vector<BCRec>& /*bcr*/,
153 0 : RunOn /*runon*/) {}
154 : };
155 :
156 :
157 : /**
158 : * \brief Bilinear interpolation on node centered data.
159 : *
160 : * Bilinear interpolation on node centered data.
161 : */
162 : class NodeBilinear
163 : :
164 : public Interpolater
165 : {
166 : public:
167 : /**
168 : * \brief Returns coarsened box given fine box and refinement ratio.
169 : *
170 : * \param fine
171 : * \param ratio
172 : */
173 : Box CoarseBox (const Box& fine, int ratio) override;
174 :
175 : /**
176 : * \brief Returns coarsened box given fine box and refinement ratio.
177 : *
178 : * \param fine
179 : * \param ratio
180 : */
181 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
182 :
183 : /**
184 : * \brief Coarse to fine interpolation in space.
185 : *
186 : * \param crse
187 : * \param crse_comp
188 : * \param fine
189 : * \param fine_comp
190 : * \param ncomp
191 : * \param fine_region
192 : * \param ratio
193 : * \param crse_geom
194 : * \param fine_geom
195 : * \param bcr
196 : * \param actual_comp
197 : * \param actual_state
198 : */
199 : void interp (const FArrayBox& crse,
200 : int crse_comp,
201 : FArrayBox& fine,
202 : int fine_comp,
203 : int ncomp,
204 : const Box& fine_region,
205 : const IntVect& ratio,
206 : const Geometry& crse_geom,
207 : const Geometry& fine_geom,
208 : Vector<BCRec> const& bcr,
209 : int actual_comp,
210 : int actual_state,
211 : RunOn runon) override;
212 : };
213 :
214 :
215 : /**
216 : * \brief Bilinear interpolation on cell centered data.
217 : *
218 : * Bilinear interpolation on cell centered data.
219 : */
220 : class CellBilinear
221 : :
222 : public Interpolater
223 : {
224 : public:
225 : /**
226 : * \brief Returns coarsened box given fine box and refinement ratio.
227 : *
228 : * \param fine
229 : * \param ratio
230 : */
231 : Box CoarseBox (const Box& fine, int ratio) override;
232 :
233 : /**
234 : * \brief Returns coarsened box given fine box and refinement ratio.
235 : *
236 : * \param fine
237 : * \param ratio
238 : */
239 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
240 :
241 : /**
242 : * \brief Coarse to fine interpolation in space.
243 : *
244 : * \param crse
245 : * \param crse_comp
246 : * \param fine
247 : * \param fine_comp
248 : * \param ncomp
249 : * \param fine_region
250 : * \param ratio
251 : * \param crse_geom
252 : * \param fine_geom
253 : * \param bcr
254 : * \param actual_comp
255 : * \param actual_state
256 : */
257 : void interp (const FArrayBox& crse,
258 : int crse_comp,
259 : FArrayBox& fine,
260 : int fine_comp,
261 : int ncomp,
262 : const Box& fine_region,
263 : const IntVect& ratio,
264 : const Geometry& crse_geom,
265 : const Geometry& fine_geom,
266 : Vector<BCRec> const& bcr,
267 : int actual_comp,
268 : int actual_state,
269 : RunOn runon) override;
270 : };
271 :
272 :
273 : /**
274 : * \brief Linear conservative interpolation on cell centered data
275 : *
276 : *
277 : * Linear conservative interpolation on cell centered data
278 : * I.e, conservative interpolation with a limiting scheme that
279 : * preserves the value of any linear combination of the
280 : * fab components; //!< e.g.,
281 : *
282 : * if sum_ivar a(ic,jc,ivar)*fab(ic,jc,ivar) = 0, then
283 : * sum_ivar a(ic,jc,ivar)*fab(if,jf,ivar) = 0 is satisfied
284 : * in all fine cells if,jf covering coarse cell ic,jc.
285 : */
286 : class CellConservativeLinear
287 : :
288 : public Interpolater
289 : {
290 : public:
291 :
292 : /**
293 : * \brief The constructor.
294 : *
295 : * \param do_linear_limiting_
296 : */
297 : explicit CellConservativeLinear (bool do_linear_limiting_= true);
298 :
299 : /**
300 : * \brief Returns coarsened box given fine box and refinement ratio.
301 : *
302 : * \param fine
303 : * \param ratio
304 : */
305 : Box CoarseBox (const Box& fine, int ratio) override;
306 :
307 : /**
308 : * \brief Returns coarsened box given fine box and refinement ratio.
309 : *
310 : * \param fine
311 : * \param ratio
312 : */
313 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
314 : /**
315 : * \brief Coarse to fine interpolation in space.
316 : */
317 : void interp (const FArrayBox& crse,
318 : int crse_comp,
319 : FArrayBox& fine,
320 : int fine_comp,
321 : int ncomp,
322 : const Box& fine_region,
323 : const IntVect& ratio,
324 : const Geometry& crse_geom,
325 : const Geometry& fine_geom,
326 : Vector<BCRec> const& bcr,
327 : int /*actual_comp*/,
328 : int /*actual_state*/,
329 : RunOn runon) override;
330 :
331 : protected:
332 :
333 : bool do_linear_limiting;
334 : };
335 :
336 :
337 : /**
338 : * \brief Lin. cons. interp. on cc data with protection against under/over-shoots.
339 : *
340 : * Linear conservative interpolation on cell centered data
341 : * but with protection against undershoots or overshoots.
342 : */
343 : class CellConservativeProtected
344 : :
345 : public CellConservativeLinear
346 : {
347 : public:
348 :
349 : /**
350 : * \brief The constructor.
351 : */
352 : CellConservativeProtected ();
353 :
354 : /**
355 : * \brief Re-visit the interpolation to protect against under- or overshoots.
356 : *
357 : * \param crse
358 : * \param crse_comp
359 : * \param fine
360 : * \param fine_comp
361 : * \param fine_state
362 : * \param state_comp
363 : * \param ncomp
364 : * \param fine_region
365 : * \param ratio
366 : * \param crse_geom
367 : * \param fine_geom
368 : * \param bcr
369 : */
370 : void protect (const FArrayBox& crse,
371 : int crse_comp,
372 : FArrayBox& fine,
373 : int fine_comp,
374 : FArrayBox& fine_state,
375 : int state_comp,
376 : int ncomp,
377 : const Box& fine_region,
378 : const IntVect& ratio,
379 : const Geometry& crse_geom,
380 : const Geometry& fine_geom,
381 : Vector<BCRec>& bcr,
382 : RunOn runon) override;
383 : };
384 :
385 :
386 : /**
387 : * \brief Quadratic interpolation on cell centered data.
388 : *
389 : * Quadratic interpolation on cell centered data.
390 : */
391 : class CellQuadratic
392 : :
393 : public Interpolater
394 : {
395 : public:
396 :
397 : /**
398 : * \brief Returns coarsened box given fine box and refinement ratio.
399 : *
400 : * \param fine
401 : * \param ratio
402 : */
403 : Box CoarseBox (const Box& fine, int ratio) override;
404 :
405 : /**
406 : * \brief Returns coarsened box given fine box and refinement ratio.
407 : *
408 : * \param fine
409 : * \param ratio
410 : */
411 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
412 :
413 : /**
414 : * \brief Coarse to fine interpolation in space.
415 : *
416 : * \param crse
417 : * \param crse_comp
418 : * \param fine
419 : * \param fine_comp
420 : * \param ncomp
421 : * \param fine_region
422 : * \param ratio
423 : * \param crse_geom
424 : * \param fine_geom
425 : * \param bcr
426 : * \param actual_comp
427 : * \param actual_state
428 : */
429 : void interp (const FArrayBox& crse,
430 : int crse_comp,
431 : FArrayBox& fine,
432 : int fine_comp,
433 : int ncomp,
434 : const Box& fine_region,
435 : const IntVect& ratio,
436 : const Geometry& crse_geom,
437 : const Geometry& fine_geom,
438 : Vector<BCRec> const& bcr,
439 : int actual_comp,
440 : int actual_state,
441 : RunOn runon) override;
442 : };
443 :
444 :
445 : /**
446 : * \brief Piecewise Constant interpolation on cell centered data.
447 : */
448 : class PCInterp
449 : :
450 : public Interpolater
451 : {
452 : public:
453 : /**
454 : * \brief Returns coarsened box given fine box and refinement ratio.
455 : *
456 : * \param fine
457 : * \param ratio
458 : */
459 : Box CoarseBox (const Box& fine, int ratio) override;
460 :
461 : /**
462 : * \brief Returns coarsened box given fine box and refinement ratio.
463 : *
464 : * \param fine
465 : * \param ratio
466 : */
467 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
468 :
469 : /**
470 : * \brief Coarse to fine interpolation in space.
471 : *
472 : * \param crse
473 : * \param crse_comp
474 : * \param fine
475 : * \param fine_comp
476 : * \param ncomp
477 : * \param fine_region
478 : * \param ratio
479 : * \param crse_geom
480 : * \param fine_geom
481 : * \param bcr
482 : * \param actual_comp
483 : * \param actual_state
484 : */
485 : void interp (const FArrayBox& crse,
486 : int crse_comp,
487 : FArrayBox& fine,
488 : int fine_comp,
489 : int ncomp,
490 : const Box& fine_region,
491 : const IntVect& ratio,
492 : const Geometry& crse_geom,
493 : const Geometry& fine_geom,
494 : Vector<BCRec> const& bcr,
495 : int actual_comp,
496 : int actual_state,
497 : RunOn runon) override;
498 : };
499 :
500 :
501 : /**
502 : * \brief Conservative quartic interpolation on cell averaged data.
503 : *
504 : * An order 4 polynomial is used to fit the data. For each cell involved
505 : * in constructing the polynomial, the average of the polynomial inside that
506 : * cell is equal to the cell averaged value of the original data.
507 : */
508 : class CellConservativeQuartic
509 : :
510 : public Interpolater
511 : {
512 : public:
513 : /**
514 : * \brief Returns coarsened box given fine box and refinement ratio.
515 : *
516 : * \param fine
517 : * \param ratio
518 : */
519 : Box CoarseBox (const Box& fine, int ratio) override;
520 :
521 : /**
522 : * \brief Returns coarsened box given fine box and refinement ratio.
523 : *
524 : * \param fine
525 : * \param ratio
526 : */
527 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
528 :
529 : /**
530 : * \brief Coarse to fine interpolation in space.
531 : *
532 : * \param crse
533 : * \param crse_comp
534 : * \param fine
535 : * \param fine_comp
536 : * \param ncomp
537 : * \param fine_region
538 : * \param ratio
539 : * \param crse_geom
540 : * \param fine_geom
541 : * \param bcr
542 : * \param actual_comp
543 : * \param actual_state
544 : */
545 : void interp (const FArrayBox& crse,
546 : int crse_comp,
547 : FArrayBox& fine,
548 : int fine_comp,
549 : int ncomp,
550 : const Box& fine_region,
551 : const IntVect& ratio,
552 : const Geometry& crse_geom,
553 : const Geometry& fine_geom,
554 : Vector<BCRec> const& bcr,
555 : int actual_comp,
556 : int actual_state,
557 : RunOn runon) override;
558 : };
559 :
560 : /**
561 : * \brief Divergence-preserving interpolation on face centered data.
562 : *
563 : * Divergence-preserving interpolation on face centered data,
564 : * i.e., it ensures the divergence of the fine ghost cells match the value
565 : * of the divergence of the underlying crse cell. All fine cells overlying
566 : * a given coarse cell will have the same divergence, even when the coarse
567 : * grid divergence is spatially varying.
568 : * Based on Vanella et. al. (doi:10.1016/j.jcp.2010.05.003, section 3.2),
569 : * but solves the interior closure problem using least squares with an
570 : * initial guess equal to the average of fine face values across the cell.
571 : */
572 : class FaceDivFree
573 : :
574 : public Interpolater
575 : {
576 : public:
577 : /**
578 : * \brief Returns coarsened box given fine box and refinement ratio.
579 : *
580 : * \param fine
581 : * \param ratio
582 : */
583 : Box CoarseBox (const Box& fine, int ratio) override;
584 :
585 : /**
586 : * \brief Returns coarsened box given fine box and refinement ratio.
587 : *
588 : * \param fine
589 : * \param ratio
590 : */
591 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
592 :
593 : /**
594 : * \brief Coarse to fine interpolation in space.
595 : *
596 : * \param crse
597 : * \param crse_comp
598 : * \param fine
599 : * \param fine_comp
600 : * \param ncomp
601 : * \param fine_region
602 : * \param ratio
603 : * \param crse_geom
604 : * \param fine_geom
605 : * \param bcr
606 : * \param actual_comp
607 : * \param actual_state
608 : * \param runon
609 : */
610 : void interp (const FArrayBox& crse,
611 : int crse_comp,
612 : FArrayBox& fine,
613 : int fine_comp,
614 : int ncomp,
615 : const Box& fine_region,
616 : const IntVect& ratio,
617 : const Geometry& crse_geom,
618 : const Geometry& fine_geom,
619 : Vector<BCRec> const& bcr,
620 : int actual_comp,
621 : int actual_state,
622 : RunOn runon) override;
623 :
624 : /**
625 : * \brief Coarse to fine interpolation in space.
626 : *
627 : * \param crse
628 : * \param crse_comp
629 : * \param fine
630 : * \param fine_comp
631 : * \param ncomp
632 : * \param fine_region
633 : * \param ratio
634 : * \param solve_mask
635 : * \param crse_geom
636 : * \param fine_geom
637 : * \param bcr
638 : * \param actual_comp
639 : * \param actual_state
640 : * \param runon
641 : */
642 : void interp_arr (Array<FArrayBox*, AMREX_SPACEDIM> const& crse,
643 : int crse_comp,
644 : Array<FArrayBox*, AMREX_SPACEDIM> const& fine,
645 : int fine_comp,
646 : int ncomp,
647 : const Box& fine_region,
648 : const IntVect& ratio,
649 : Array<IArrayBox*, AMREX_SPACEDIM> const& solve_mask,
650 : const Geometry& crse_geom,
651 : const Geometry& fine_geom,
652 : Vector<Array<BCRec, AMREX_SPACEDIM> > const& bcr,
653 : int actual_comp,
654 : int actual_state,
655 : RunOn runon) override;
656 : };
657 :
658 :
659 : /**
660 : * \brief Piecewise constant tangential interpolation / linear normal interpolation of face data.
661 : *
662 : * Piecewise constant tangential interpolation / linear normal interpolation of face data.
663 : */
664 : class FaceLinear
665 : :
666 : public Interpolater
667 : {
668 : public:
669 : /**
670 : * \brief Returns coarsened box given fine box and refinement ratio.
671 : *
672 : * \param fine
673 : * \param ratio
674 : */
675 : Box CoarseBox (const Box& fine, int ratio) override;
676 :
677 : /**
678 : * \brief Returns coarsened box given fine box and refinement ratio.
679 : *
680 : * \param fine
681 : * \param ratio
682 : */
683 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
684 :
685 : /**
686 : * \brief Coarse to fine interpolation in space.
687 : *
688 : * \param crse
689 : * \param crse_comp
690 : * \param fine
691 : * \param fine_comp
692 : * \param ncomp
693 : * \param fine_region
694 : * \param ratio
695 : * \param crse_geom
696 : * \param fine_geom
697 : * \param bcr
698 : * \param actual_comp
699 : * \param actual_state
700 : */
701 : void interp (const FArrayBox& crse,
702 : int crse_comp,
703 : FArrayBox& fine,
704 : int fine_comp,
705 : int ncomp,
706 : const Box& fine_region,
707 : const IntVect& ratio,
708 : const Geometry& crse_geom,
709 : const Geometry& fine_geom,
710 : Vector<BCRec> const& bcr,
711 : int actual_comp,
712 : int actual_state,
713 : RunOn runon) override;
714 :
715 : /**
716 : * \brief Coarse to fine interpolation in space for face-based data.
717 : *
718 : * \param crse
719 : * \param crse_comp
720 : * \param fine
721 : * \param fine_comp
722 : * \param ncomp
723 : * \param fine_region
724 : * \param ratio
725 : * \param solve_mask
726 : * \param crse_geom
727 : * \param fine_geom
728 : * \param bcr
729 : * \param bccomp
730 : * \param runon
731 : */
732 : void interp_face (const FArrayBox& crse,
733 : int crse_comp,
734 : FArrayBox& fine,
735 : int fine_comp,
736 : int ncomp,
737 : const Box& fine_region,
738 : const IntVect& ratio,
739 : const IArrayBox& solve_mask,
740 : const Geometry& crse_geom,
741 : const Geometry& fine_geom,
742 : Vector<BCRec> const & bcr,
743 : int bccomp,
744 : RunOn runon) override;
745 :
746 : /**
747 : * \brief Coarse to fine interpolation in space.
748 : *
749 : * \param crse
750 : * \param crse_comp
751 : * \param fine
752 : * \param fine_comp
753 : * \param ncomp
754 : * \param fine_region
755 : * \param ratio
756 : * \param crse_geom
757 : * \param fine_geom
758 : * \param bcr
759 : * \param actual_comp
760 : * \param actual_state
761 : */
762 : void interp_arr (Array<FArrayBox*, AMREX_SPACEDIM> const& crse,
763 : int crse_comp,
764 : Array<FArrayBox*, AMREX_SPACEDIM> const& fine,
765 : int fine_comp,
766 : int ncomp,
767 : const Box& fine_region,
768 : const IntVect& ratio,
769 : Array<IArrayBox*, AMREX_SPACEDIM> const& solve_mask,
770 : const Geometry& /*crse_geom*/,
771 : const Geometry& /*fine_geom*/,
772 : Vector<Array<BCRec, AMREX_SPACEDIM> > const& /*bcr*/,
773 : int /*actual_comp*/,
774 : int /*actual_state*/,
775 : RunOn runon) override;
776 :
777 :
778 : };
779 :
780 : /**
781 : * \brief Bilinear tangential interpolation / linear normal interpolation of face data.
782 : *
783 : * Bilinear tangential interpolation / linear normal interpolation of face data.
784 : */
785 : class FaceConservativeLinear
786 : :
787 : public Interpolater
788 : {
789 : public:
790 : /**
791 : * \brief Returns coarsened box given fine box and refinement ratio.
792 : *
793 : * \param fine
794 : * \param ratio
795 : */
796 : Box CoarseBox (const Box& fine, int ratio) override;
797 :
798 : /**
799 : * \brief Returns coarsened box given fine box and refinement ratio.
800 : *
801 : * \param fine
802 : * \param ratio
803 : */
804 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
805 :
806 : /**
807 : * \brief Coarse to fine interpolation in space.
808 : *
809 : * \param crse
810 : * \param crse_comp
811 : * \param fine
812 : * \param fine_comp
813 : * \param ncomp
814 : * \param fine_region
815 : * \param ratio
816 : * \param crse_geom
817 : * \param fine_geom
818 : * \param bcr
819 : * \param actual_comp
820 : * \param actual_state
821 : */
822 : void interp (const FArrayBox& crse,
823 : int crse_comp,
824 : FArrayBox& fine,
825 : int fine_comp,
826 : int ncomp,
827 : const Box& fine_region,
828 : const IntVect& ratio,
829 : const Geometry& crse_geom,
830 : const Geometry& fine_geom,
831 : Vector<BCRec> const& bcr,
832 : int actual_comp,
833 : int actual_state,
834 : RunOn runon) override;
835 :
836 : /**
837 : * \brief Coarse to fine interpolation in space for face-based data.
838 : *
839 : * \param crse
840 : * \param crse_comp
841 : * \param fine
842 : * \param fine_comp
843 : * \param ncomp
844 : * \param fine_region
845 : * \param ratio
846 : * \param solve_mask
847 : * \param crse_geom
848 : * \param fine_geom
849 : * \param bcr
850 : * \param bccomp
851 : * \param runon
852 : */
853 : void interp_face (const FArrayBox& crse,
854 : int crse_comp,
855 : FArrayBox& fine,
856 : int fine_comp,
857 : int ncomp,
858 : const Box& fine_region,
859 : const IntVect& ratio,
860 : const IArrayBox& solve_mask,
861 : const Geometry& crse_geom,
862 : const Geometry& fine_geom,
863 : Vector<BCRec> const & bcr,
864 : int bccomp,
865 : RunOn runon) override;
866 :
867 : /**
868 : * \brief Coarse to fine interpolation in space.
869 : *
870 : * \param crse
871 : * \param crse_comp
872 : * \param fine
873 : * \param fine_comp
874 : * \param ncomp
875 : * \param fine_region
876 : * \param ratio
877 : * \param crse_geom
878 : * \param fine_geom
879 : * \param bcr
880 : * \param actual_comp
881 : * \param actual_state
882 : */
883 : void interp_arr (Array<FArrayBox*, AMREX_SPACEDIM> const& crse,
884 : int crse_comp,
885 : Array<FArrayBox*, AMREX_SPACEDIM> const& fine,
886 : int fine_comp,
887 : int ncomp,
888 : const Box& fine_region,
889 : const IntVect& ratio,
890 : Array<IArrayBox*, AMREX_SPACEDIM> const& solve_mask,
891 : const Geometry& /*crse_geom*/,
892 : const Geometry& /*fine_geom*/,
893 : Vector<Array<BCRec, AMREX_SPACEDIM> > const& /*bcr*/,
894 : int /*actual_comp*/,
895 : int /*actual_state*/,
896 : RunOn runon) override;
897 :
898 :
899 : };
900 :
901 : /**
902 : * \brief Quartic interpolation on cell centered data.
903 : *
904 : * Quartic interpolation on cell centered data.
905 : */
906 : class CellQuartic
907 : :
908 : public Interpolater
909 : {
910 : public:
911 : /**
912 : * \brief Returns coarsened box given fine box and refinement ratio.
913 : *
914 : * \param fine
915 : * \param ratio
916 : */
917 : Box CoarseBox (const Box& fine, int ratio) override;
918 :
919 : /**
920 : * \brief Returns coarsened box given fine box and refinement ratio.
921 : *
922 : * \param fine
923 : * \param ratio
924 : */
925 : Box CoarseBox (const Box& fine, const IntVect& ratio) override;
926 :
927 : /**
928 : * \brief Coarse to fine interpolation in space.
929 : *
930 : * \param crse
931 : * \param crse_comp
932 : * \param fine
933 : * \param fine_comp
934 : * \param ncomp
935 : * \param fine_region
936 : * \param ratio
937 : * \param crse_geom
938 : * \param fine_geom
939 : * \param bcr
940 : * \param actual_comp
941 : * \param actual_state
942 : */
943 : void interp (const FArrayBox& crse,
944 : int crse_comp,
945 : FArrayBox& fine,
946 : int fine_comp,
947 : int ncomp,
948 : const Box& fine_region,
949 : const IntVect& ratio,
950 : const Geometry& crse_geom,
951 : const Geometry& fine_geom,
952 : Vector<BCRec> const& bcr,
953 : int actual_comp,
954 : int actual_state,
955 : RunOn runon) override;
956 : };
957 :
958 : //! CONSTRUCT A GLOBAL OBJECT OF EACH VERSION.
959 : extern AMREX_EXPORT PCInterp pc_interp;
960 : extern AMREX_EXPORT NodeBilinear node_bilinear_interp;
961 : extern AMREX_EXPORT FaceDivFree face_divfree_interp;
962 : extern AMREX_EXPORT FaceLinear face_linear_interp;
963 : extern AMREX_EXPORT FaceConservativeLinear face_cons_linear_interp;
964 : extern AMREX_EXPORT CellConservativeLinear lincc_interp;
965 : extern AMREX_EXPORT CellConservativeLinear cell_cons_interp;
966 : extern AMREX_EXPORT CellBilinear cell_bilinear_interp;
967 : extern AMREX_EXPORT CellConservativeProtected protected_interp;
968 : extern AMREX_EXPORT CellConservativeQuartic quartic_interp;
969 : extern AMREX_EXPORT CellQuadratic quadratic_interp;
970 : extern AMREX_EXPORT CellQuartic cell_quartic_interp;
971 :
972 : }
973 :
974 : #endif /*_INTERPOLATER_H_*/
|
