Line data    Source code

       1             : //
       2             : // This is the mechanism for impositing boundary conditions on :code:`Set::Field` objects of 
       3             : // scalar type.
       4             : // Typical convention is for :code:`[prefix]` to be given by the field name. For instance,
       5             : // 
       6             : // .. code-block:: make
       7             : // 
       8             : //                 bc.temp.type.xhi = dirichlet dirichlet dirichlet
       9             : //                 bc.temp.val.xhi  = 0.0 1.0 0.0
      10             : //
      11             : // corresponds to the boundary condition for temperature. See the specific integrator
      12             : // for details.
      13             : //
      14             : 
      15             : #ifndef BC_BC_H_
      16             : #define BC_BC_H_
      17             : 
      18             : #include <AMReX_ParallelDescriptor.H>
      19             : #include <AMReX_ParmParse.H>
      20             : #include <AMReX_BCRec.H>
      21             : #include <AMReX_PhysBCFunct.H>
      22             : #include <AMReX_LO_BCTYPES.H>
      23             : #include <AMReX_Mask.H>
      24             : #include <AMReX_Periodicity.H>
      25             : 
      26             : #include "Util/Util.H"
      27             : #include "Set/Set.H"
      28             : 
      29             : /// \brief Collection of boundary condition (BC) objects
      30             : namespace BC
      31             : {
      32             : enum Orientation {
      33             :     All = -1,
      34             :     AMREX_D_DECL(xlo = 0,
      35             :     ylo = 1,
      36             :     zlo = 2),
      37             :     AMREX_D_DECL(xhi = 0 + AMREX_SPACEDIM,
      38             :     yhi = 1 + AMREX_SPACEDIM,
      39             :     zhi = 2 + AMREX_SPACEDIM)
      40             : };
      41             : 
      42             : template<class T>
      43             : class BC
      44             : {
      45             : 
      46             : public:
      47          40 :     virtual ~BC() {};
      48             : 
      49      218397 :     void define(const amrex::Geometry& a_geom) { m_geom = a_geom; };
      50             : 
      51             :     virtual void FillBoundary(amrex::BaseFab<T>& in,
      52             :         const amrex::Box& box,
      53             :         int ngrow, int dcomp, int ncomp,
      54             :         amrex::Real time,
      55             :         Orientation face = Orientation::All,
      56             :         const amrex::Mask* mask = nullptr) = 0;
      57             : 
      58           0 :     virtual void FillBoundary(amrex::FabArray<amrex::BaseFab<T>>& mf,
      59             :         int dcomp, int ncomp,
      60             :         amrex::Real time, int /*bccomp*/)
      61             :     {
      62           0 :         mf.FillBoundary(m_geom.periodicity());
      63           0 :         for (amrex::MFIter mfi(mf, true); mfi.isValid(); ++mfi)
      64             :         {
      65           0 :             const amrex::Box& box = mfi.tilebox();
      66           0 :             amrex::BaseFab<T>& in = mf[mfi];
      67           0 :             FillBoundary(in, box, mf.nGrow(), dcomp, ncomp, time);
      68             :         }
      69           0 :     }
      70             : 
      71           0 :     virtual void FillBoundary(amrex::FabArray<amrex::BaseFab<T>>& mf,
      72             :         int dcomp, int ncomp, amrex::IntVect const& /*nghost*/,
      73             :         amrex::Real time, int bccomp) //override
      74             :     {
      75           0 :         FillBoundary(mf, dcomp, ncomp, time, bccomp);
      76           0 :     }
      77             : 
      78           0 :     void operator () (amrex::FabArray<amrex::BaseFab<T>>& mf,
      79             :         int dcomp, int ncomp, amrex::IntVect const& /*nghost*/,
      80             :         amrex::Real time, int bccomp)
      81             :     {
      82           0 :         FillBoundary(mf, dcomp, ncomp, time, bccomp);
      83           0 :     }
      84             : 
      85             : 
      86             : 
      87             :     template <class Q = T>
      88             :     typename std::enable_if<std::is_same<Q, amrex::Real>::value>::type
      89      431673 :         FillBoundary(amrex::MultiFab& mf,
      90             :             int dcomp, int ncomp,
      91             :             amrex::Real time, int /*bccomp*/)
      92             :     {
      93      431673 :         mf.FillBoundary(m_geom.periodicity());
      94     2372244 :         for (amrex::MFIter mfi(mf, true); mfi.isValid(); ++mfi)
      95             :         {
      96     1940576 :             const amrex::Box& box = mfi.tilebox();
      97     1940576 :             amrex::BaseFab<T>& in = mf[mfi];
      98     1940576 :             FillBoundary(in, box, mf.nGrow(), dcomp, ncomp, time);
      99             :         }
     100      431673 :     }
     101             : 
     102             :     template <class Q = T>
     103             :     typename std::enable_if<std::is_same<Q, amrex::Real>::value>::type
     104      431422 :         operator () (amrex::MultiFab& mf,
     105             :             int dcomp, int ncomp, amrex::IntVect const& /*nghost*/,
     106             :             amrex::Real time, int bccomp)
     107             :     {
     108      431422 :         FillBoundary(mf, dcomp, ncomp, time, bccomp);
     109      431422 :     }
     110             : 
     111             : 
     112             :     virtual amrex::BCRec GetBCRec() = 0;
     113             : 
     114           0 :     virtual amrex::Array<int, AMREX_SPACEDIM> IsPeriodic()
     115             :     {
     116           0 :         return { {AMREX_D_DECL(m_geom.isPeriodic(0),m_geom.isPeriodic(1),m_geom.isPeriodic(2))} };
     117             :     }
     118             : 
     119           0 :     virtual amrex::Periodicity Periodicity() const {
     120           0 :         return m_geom.periodicity();
     121             :     }
     122             : 
     123           0 :     virtual amrex::Periodicity Periodicity(const amrex::Box& b) {
     124           0 :         return m_geom.periodicity(b);
     125             :     }
     126             : 
     127             : 
     128             : protected:
     129             :     amrex::Geometry m_geom;
     130             :     //std::vector<amrex::Geometry> &geom;
     131             :     //int lev=0;
     132             : };
     133             : 
     134             : namespace BCUtil
     135             : {
     136             : int ReadString(std::string bcstring);
     137             : bool IsPeriodic(int bctype);
     138             : bool IsNeumann(int bctype);
     139             : bool IsReflectEven(int bctype);
     140             : bool IsReflectOdd(int bctype);
     141             : bool IsDirichlet(int bctype);
     142             : }
     143             : 
     144             : }
     145             : #endif