#include <ERF_SampleData.H>

Collaboration diagram for LineSampler:

[legend]

Public Member Functions
	LineSampler ()

void	get_line_mfs (amrex::Vector< amrex::Vector< amrex::MultiFab >> &vars_new)

void	write_line_mfs (amrex::Vector< amrex::Real > &time, amrex::Vector< int > &level_steps, amrex::Vector< amrex::IntVect > &ref_ratio, amrex::Vector< amrex::Geometry > &geom)

Public Attributes
amrex::Vector< int >	m_dir

amrex::Vector< int >	m_lev

amrex::Vector< amrex::Box >	m_bnd_bx

amrex::Vector< amrex::MultiFab >	m_ls_mf

Constructor & Destructor Documentation

◆ LineSampler()

LineSampler::LineSampler ( )

inline

     {
         amrex::ParmParse pp("erf");
  
         // Count number of lo and hi points define the line
         int n_line_lo  = pp.countval("sample_line_lo") / AMREX_SPACEDIM;
         int n_line_hi  = pp.countval("sample_line_hi") / AMREX_SPACEDIM;
         int n_line_dir = pp.countval("sample_line_dir");
         AMREX_ALWAYS_ASSERT( (n_line_lo==n_line_hi ) &&
                              (n_line_lo==n_line_dir) );
  
         // Parse the data
         if (n_line_lo > 0) {
             // Parse lo
             amrex::Vector<int> idx_lo; idx_lo.resize(n_line_lo*AMREX_SPACEDIM);
             amrex::Vector<amrex::IntVect> iv_lo; iv_lo.resize(n_line_lo);
             pp.queryarr("sample_line_lo",idx_lo,0,n_line_lo*AMREX_SPACEDIM);
             for (int i(0); i < n_line_lo; i++) {
                 amrex::IntVect iv(idx_lo[AMREX_SPACEDIM*i+0],
                                   idx_lo[AMREX_SPACEDIM*i+1],
                                   idx_lo[AMREX_SPACEDIM*i+2]);
                 iv_lo[i] = iv;
             }
  
             // Parse hi
             amrex::Vector<int> idx_hi; idx_hi.resize(n_line_hi*AMREX_SPACEDIM);
             amrex::Vector<amrex::IntVect> iv_hi; iv_hi.resize(n_line_hi);
             pp.queryarr("sample_line_hi",idx_hi,0,n_line_hi*AMREX_SPACEDIM);
             for (int i(0); i < n_line_hi; i++) {
                 amrex::IntVect iv(idx_hi[AMREX_SPACEDIM*i+0],
                                   idx_hi[AMREX_SPACEDIM*i+1],
                                   idx_hi[AMREX_SPACEDIM*i+2]);
                 iv_hi[i] = iv;
             }
  
             // Construct vector of bounding boxes
             m_bnd_bx.resize(n_line_lo);
             for (int i = 0; i < n_line_hi; i++){
                 amrex::Box lbx(iv_lo[i],iv_hi[i]);
                 m_bnd_bx[i] = lbx;
             }
  
             // Parse directionality
             m_dir.resize(n_line_dir);
             pp.queryarr("sample_line_dir",m_dir,0,n_line_dir);
  
             // Allocate space for level indicator
             m_lev.resize(n_line_dir,0);
  
             // Allocate space for MF pointers
             m_ls_mf.resize(n_line_lo);
         }
     }

Here is the call graph for this function:

Member Function Documentation

◆ get_line_mfs()

void LineSampler::get_line_mfs ( amrex::Vector< amrex::Vector< amrex::MultiFab >> & vars_new )

inline

     {
         int nlev  = vars_new.size();
         int nline = m_bnd_bx.size();
         int ncomp  = 2;
  
         // Loop over each line
         for (int iline(0); iline<nline; ++iline) {
             int dir = m_dir[iline];
             amrex::Box bnd_bx   = m_bnd_bx[iline];
             amrex::IntVect cell = bnd_bx.smallEnd();
  
             // Search each level to get the finest data possible
             for (int ilev(nlev-1); ilev>=0; --ilev) {
  
                 // Construct CC velocities
                 amrex::MultiFab mf_cc_vel;
                 auto ba = vars_new[ilev][Vars::cons].boxArray();
                 auto dm = vars_new[ilev][Vars::cons].DistributionMap();
                 mf_cc_vel.define(ba, dm, AMREX_SPACEDIM, amrex::IntVect(1,1,1));
                 average_face_to_cellcenter(mf_cc_vel,0,
                                            amrex::Array<const amrex::MultiFab*,3>{&vars_new[ilev][Vars::xvel],
                                                                                   &vars_new[ilev][Vars::yvel],
                                                                                   &vars_new[ilev][Vars::zvel]});
  
                 // Construct vector of MFs holding T and WSP
                 amrex::MultiFab mf_cc_data;
                 mf_cc_data.define(ba, dm, ncomp, 1);
 #ifdef _OPENMP
 #pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
 #endif
                 for (amrex::MFIter mfi(mf_cc_data, amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi) {
                     const amrex::Box& tbx = mfi.tilebox();
                     auto const& dfab = mf_cc_data.array(mfi);
                     auto const& tfab = vars_new[ilev][Vars::cons].array(mfi);
                     auto const& wfab = mf_cc_vel.array(mfi);
                     amrex::ParallelFor(tbx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
                     {
                         dfab(i,j,k,0) = tfab(i,j,k,1)/tfab(i,j,k,0);
                         dfab(i,j,k,1) = std::sqrt(wfab(i,j,k,0)*wfab(i,j,k,0)
                                                 + wfab(i,j,k,1)*wfab(i,j,k,1)
                                                 + wfab(i,j,k,2)*wfab(i,j,k,2)) ;
                     });
  
                 }
  
                   m_lev[iline] = ilev;
                 m_ls_mf[iline] = get_line_data(mf_cc_data, dir, cell, bnd_bx);
  
                 // We can stop if we got the entire line
                 auto min_bnd_bx = m_ls_mf[iline].boxArray().minimalBox();
                 if (bnd_bx == min_bnd_bx) { continue; }
  
             } // ilev
         }// iline
     }

◆ write_line_mfs()

void LineSampler::write_line_mfs	(	amrex::Vector< amrex::Real > &	time,
		amrex::Vector< int > &	level_steps,
		amrex::Vector< amrex::IntVect > &	ref_ratio,
		amrex::Vector< amrex::Geometry > &	geom
	)

inline

     {
         std::string name_base = "plt_line_";
         amrex::Vector<std::string> varnames = {"T", "Wsp"};
  
         int nline = m_ls_mf.size();
         for (int iline(0); iline<nline; ++iline) {
             // Data members that can be used as-is
             int dir = m_dir[iline];
             int lev = m_lev[iline];
             amrex::Real m_time = time[lev];
             amrex::Vector<int> m_level_steps = {level_steps[lev]};
             amrex::Vector<amrex::IntVect> m_ref_ratio  = {ref_ratio[lev]};
  
             // Create modified geometry object corresponding to the line
             auto plo = geom[lev].ProbLo();
             auto dx  = geom[lev].CellSize();
             amrex::Vector<amrex::Geometry> m_geom; m_geom.resize(1);
             amrex::Vector<int> is_per(AMREX_SPACEDIM,0);
             amrex::Box m_dom = m_bnd_bx[iline];
             amrex::RealBox m_rb;
             for (int d(0); d<AMREX_SPACEDIM; ++d) {
                 amrex::Real offset = (d==dir) ? 0 : 0.5;
                 amrex::Real lo = plo[d] + ( m_dom.smallEnd(d) - offset ) * dx[d];
                 amrex::Real hi = plo[d] + ( m_dom.bigEnd(d)   + offset ) * dx[d];
  
                 m_rb.setLo(d,lo);
                 m_rb.setHi(d,hi);
  
                 is_per[d] = geom[lev].isPeriodic(d);
             }
             m_geom[0].define(m_dom, &m_rb, geom[lev].Coord(), is_per.data());
  
             // Create plotfile name
             std::string name_line    = amrex::Concatenate(name_base, iline           , 5);
             name_line += "_step_";
             std::string plotfilename = amrex::Concatenate(name_line, m_level_steps[0], 5);
  
             // Get the data
             amrex::Vector<const amrex::MultiFab*> mf = {&(m_ls_mf[iline])};
  
             // Write each line
             WriteMultiLevelPlotfile(plotfilename, 1, mf,
                                     varnames, m_geom, m_time,
                                     m_level_steps, m_ref_ratio);
         }
     }