Line data    Source code

       1             : //
       2             : // .. warning::
       3             : //    This will be replaced by the more general :code:`BC::Expression`
       4             : //
       5             : 
       6             : 
       7             : 
       8             : #ifndef BC_STEP_H_
       9             : #define BC_STEP_H_
      10             : 
      11             : #include <AMReX_ParallelDescriptor.H>
      12             : #include <AMReX_ParmParse.H>
      13             : #include <AMReX_BCRec.H>
      14             : #include <AMReX_PhysBCFunct.H>
      15             : #include <AMReX_Array.H>
      16             : 
      17             : #include "Set/Set.H"
      18             : #include "BC/BC.H"
      19             : #include "BC/Constant.H"
      20             : namespace BC
      21             : {
      22             : class Step
      23             :     : public BC<Set::Scalar>
      24             : {
      25             : public:
      26             :     static constexpr const char* name = "step";
      27             : 
      28             :     Step() {}
      29           0 :     Step(int ngrains, IO::ParmParse& pp, std::string name)
      30           0 :     {
      31           0 :         Util::AssertException(INFO,TEST(ngrains==2));
      32           0 :         pp_queryclass(name, *this);
      33           0 :     }
      34             : 
      35           0 :     void FillBoundary(amrex::BaseFab<Set::Scalar>& a_in,
      36             :         const amrex::Box& a_box,
      37             :         int ngrow, int /*dcomp*/, int /*ncomp*/, amrex::Real /*time*/,
      38             :         Orientation face, const amrex::Mask* /*mask*/) override
      39             :     {
      40             : 
      41           0 :         const amrex::Real* DX = m_geom.CellSize();
      42             : 
      43           0 :         amrex::Box box = a_box;
      44           0 :         box.grow(ngrow);
      45           0 :         const amrex::Dim3 lo = amrex::lbound(m_geom.Domain()), hi = amrex::ubound(m_geom.Domain());
      46             : 
      47           0 :         amrex::Array4<amrex::Real> const& in = a_in.array();
      48             : 
      49           0 :         amrex::ParallelFor(box, [=] AMREX_GPU_DEVICE(int i, int j, int k)
      50             :         {
      51           0 :             amrex::IntVect glevel;
      52           0 :             AMREX_D_TERM(glevel[0] = std::max(std::min(0, i - lo.x), i - hi.x);,
      53             :                 glevel[1] = std::max(std::min(0, j - lo.y), j - hi.y);,
      54             :                 glevel[2] = std::max(std::min(0, k - lo.z), k - hi.z); );
      55             : 
      56           0 :             Set::Vector x;
      57           0 :             AMREX_D_TERM(x(0) = m_geom.ProbLo()[0] + ((Set::Scalar)(i)+0.5) * DX[0];,
      58             :                 x(1) = m_geom.ProbLo()[1] + ((Set::Scalar)(j)+0.5) * DX[1];,
      59             :                 x(2) = m_geom.ProbLo()[2] + ((Set::Scalar)(k)+0.5) * DX[2];);
      60             : 
      61             : 
      62           0 :             if (glevel[0] < 0 && (face == Orientation::xlo || face == Orientation::All))
      63             :             {
      64           0 :                 if (x(1) > m_h1)
      65             :                 {
      66           0 :                     in(i, j, k, 0) = 0.;
      67           0 :                     in(i, j, k, 1) = 1.;
      68             :                 }
      69             :                 else
      70             :                 {
      71           0 :                     in(i, j, k, 0) = 1.;
      72           0 :                     in(i, j, k, 1) = 0.;
      73             :                 }
      74             :             }
      75           0 :             else if (glevel[0] > 0)
      76             :             {
      77           0 :                 if (x(1) > m_h2)
      78             :                 {
      79           0 :                     in(i, j, k, 0) = 0.;
      80           0 :                     in(i, j, k, 1) = 1.;
      81             :                 }
      82             :                 else
      83             :                 {
      84           0 :                     in(i, j, k, 0) = 1.;
      85           0 :                     in(i, j, k, 1) = 0.;
      86             :                 }
      87             :             }
      88           0 :             else if (glevel[1] < 0) // Bottom boundary
      89             :             {
      90           0 :                 in(i, j, k, 0) = 1.;
      91           0 :                 in(i, j, k, 1) = 0.;
      92             :             }
      93           0 :             else if (glevel[1] > 0 && (face == Orientation::yhi || face == Orientation::All)) // Top boundary
      94             :             {
      95           0 :                 in(i, j, k, 0) = 0.;
      96           0 :                 in(i, j, k, 1) = 1.;
      97             :             }
      98           0 :         });
      99             : 
     100             : 
     101           0 :     }
     102           0 :     amrex::BCRec GetBCRec() override
     103             :     {
     104           0 :         int bc_lo[AMREX_SPACEDIM] =
     105             :         { AMREX_D_DECL(amrex::BCType::mathematicalBndryTypes::int_dir,
     106             :         amrex::BCType::mathematicalBndryTypes::int_dir,
     107             :         amrex::BCType::mathematicalBndryTypes::int_dir) };
     108           0 :         int bc_hi[AMREX_SPACEDIM] =
     109             :         { AMREX_D_DECL(amrex::BCType::mathematicalBndryTypes::int_dir,
     110             :                         amrex::BCType::mathematicalBndryTypes::int_dir,
     111             :                         amrex::BCType::mathematicalBndryTypes::int_dir) };
     112             : 
     113           0 :         return amrex::BCRec(bc_lo, bc_hi);
     114             :     }
     115             : 
     116             : private:
     117             :     Set::Scalar m_h1 = NAN, m_h2 = NAN;
     118             : 
     119             : public:
     120           0 :     static void Parse(Step& value, amrex::ParmParse& pp)
     121             :     {
     122           0 :         pp_query("h1", value.m_h1); // Location of the step on the xlo edge/face
     123           0 :         pp_query("h2", value.m_h2); // Location of the step on the xhi edge/face
     124           0 :     }
     125             : 
     126             : };
     127             : }
     128             : #endif