#include <ERF_ReadBndryPlanes.H>

Collaboration diagram for ReadBndryPlanes:

[legend]

Public Member Functions
	ReadBndryPlanes (const amrex::Geometry &geom, const amrex::Real &rdOcp_in)

void	define_level_data (int lev)

void	read_time_file ()

void	read_input_files (amrex::Real time, amrex::Real dt, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > m_bc_extdir_vals)

void	read_file (int idx, amrex::Vector< std::unique_ptr< PlaneVector >> &data_to_fill, amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max > m_bc_extdir_vals)

amrex::Vector< std::unique_ptr< PlaneVector > > &	interp_in_time (const amrex::Real &time)

amrex::Real	tinterp () const

int	ingested_velocity () const

int	ingested_theta () const

int	ingested_density () const

int	ingested_scalar () const

int	ingested_q1 () const

int	ingested_q2 () const

int	ingested_KE () const

int	ingested_QKE () const

Private Attributes
amrex::Real	m_tn
	The times for which we currently have data. More...

amrex::Real	m_tnp1

amrex::Real	m_tnp2

amrex::Vector< std::unique_ptr< PlaneVector > >	m_data_n
	Data at time m_tn. More...

amrex::Vector< std::unique_ptr< PlaneVector > >	m_data_np1
	Data at time m_tnp1. More...

amrex::Vector< std::unique_ptr< PlaneVector > >	m_data_np2
	Data at time m_tnp2. More...

amrex::Vector< std::unique_ptr< PlaneVector > >	m_data_interp
	Data interpolated to the time requested. More...

amrex::Real	m_tinterp {-1.0}
	Time for plane at interpolation. More...

amrex::Geometry	m_geom
	Geometry at level 0. More...

std::string	m_filename {""}
	File name for IO. More...

std::string	m_time_file {""}
	File name for file holding timesteps and times. More...

amrex::Vector< amrex::Real >	m_in_times
	The timesteps / times that we read from time.dat. More...

amrex::Vector< int >	m_in_timesteps

amrex::Vector< std::string >	m_var_names
	Variables to be read in. More...

const int	m_in_rad = 1
	controls extents on native bndry output More...

const int	m_out_rad = 1

const int	m_extent_rad = 0

const amrex::Real	m_rdOcp
	R_d/c_p is needed for reading boundary files. More...

int	is_velocity_read

int	is_density_read

int	is_temperature_read

int	is_theta_read

int	is_scalar_read

int	is_q1_read

int	is_q2_read

int	is_KE_read

int	is_QKE_read

int	last_file_read

Detailed Description

Collection of data structures and operations for reading data

This class contains the inlet data structures and operations to read and interpolate inflow data.

Constructor & Destructor Documentation

◆ ReadBndryPlanes()

ReadBndryPlanes::ReadBndryPlanes	(	const amrex::Geometry &	geom,
		const amrex::Real &	rdOcp_in
	)

explicit

ReadBndryPlanes class constructor. Handles initialization from inputs file parameters.

Parameters

geom	Geometry for the domain
rdOcp_in	Real constant for the Rhydberg constant ($R_d$) divided by the specific heat at constant pressure ($c_p$)

 :
     m_geom(geom),
     m_rdOcp(rdOcp_in)
 {
     ParmParse pp("erf");
  
     last_file_read = -1;
  
     m_tinterp = -1.;
  
     // What folder will the time series of planes be read from
     pp.get("bndry_file", m_filename);
  
     is_velocity_read     = 0;
     is_density_read      = 0;
     is_temperature_read  = 0;
     is_theta_read        = 0;
     is_scalar_read       = 0;
     is_q1_read           = 0;
     is_q2_read           = 0;
     is_KE_read           = 0;
     is_QKE_read          = 0;
  
     if (pp.contains("bndry_input_var_names"))
     {
         int num_vars = pp.countval("bndry_input_var_names");
         m_var_names.resize(num_vars);
         pp.queryarr("bndry_input_var_names",m_var_names,0,num_vars);
         for (int i = 0; i < m_var_names.size(); i++) {
             if (m_var_names[i] == "velocity")     is_velocity_read = 1;
             if (m_var_names[i] == "density")      is_density_read = 1;
             if (m_var_names[i] == "temperature")  is_temperature_read = 1;
             if (m_var_names[i] == "theta")        is_theta_read = 1;
             if (m_var_names[i] == "scalar")       is_scalar_read = 1;
             if (m_var_names[i] == "qv")           is_q1_read = 1;
             if (m_var_names[i] == "qc")           is_q2_read = 1;
             if (m_var_names[i] == "ke")           is_KE_read = 1;
             if (m_var_names[i] == "qke")          is_QKE_read = 1;
         }
     }
  
     // time.dat will be in the same folder as the time series of data
     m_time_file = m_filename + "/time.dat";
  
     // each pointer (at at given time) has 6 components, one for each orientation
     // TODO: we really only need 4 not 6
     int size = 2*AMREX_SPACEDIM;
     m_data_n.resize(size);
     m_data_np1.resize(size);
     m_data_np2.resize(size);
     m_data_interp.resize(size);
 }

Here is the call graph for this function:

Member Function Documentation

◆ define_level_data()

void ReadBndryPlanes::define_level_data ( int lev )

Function in ReadBndryPlanes class for allocating space for the boundary plane data ERF will need.

 {
     Print() << "ReadBndryPlanes::define_level_data" << std::endl;
     // *********************************************************
     // Allocate space for all of the boundary planes we may need
     // *********************************************************
     int ncomp = BCVars::NumTypes;
     const Box& domain = m_geom.Domain();
     for (OrientationIter oit; oit != nullptr; ++oit) {
         auto ori = oit();
         if (ori.coordDir() < 2) {
  
             m_data_n[ori]      = std::make_unique<PlaneVector>();
             m_data_np1[ori]    = std::make_unique<PlaneVector>();
             m_data_np2[ori]    = std::make_unique<PlaneVector>();
             m_data_interp[ori] = std::make_unique<PlaneVector>();
  
             const auto& lo = domain.loVect();
             const auto& hi = domain.hiVect();
  
             IntVect plo(lo);
             IntVect phi(hi);
             const int normal = ori.coordDir();
             plo[normal] = ori.isHigh() ? hi[normal] + 1 : -1;
             phi[normal] = ori.isHigh() ? hi[normal] + 1 : -1;
             const Box pbx(plo, phi);
             m_data_n[ori]->push_back(FArrayBox(pbx, ncomp));
             m_data_np1[ori]->push_back(FArrayBox(pbx, ncomp));
             m_data_np2[ori]->push_back(FArrayBox(pbx, ncomp));
             m_data_interp[ori]->push_back(FArrayBox(pbx, ncomp));
         }
     }
 }

Referenced by read_time_file().

Here is the caller graph for this function:

◆ ingested_density()

int ReadBndryPlanes::ingested_density ( ) const

inline

43 {return is_density_read;}

Referenced by read_file().

Here is the caller graph for this function:

◆ ingested_KE()

int ReadBndryPlanes::ingested_KE ( ) const

inline

47 {return is_KE_read;}

◆ ingested_q1()

int ReadBndryPlanes::ingested_q1 ( ) const

inline

45 {return is_q1_read;}

◆ ingested_q2()

int ReadBndryPlanes::ingested_q2 ( ) const

inline

46 {return is_q2_read;}

◆ ingested_QKE()

int ReadBndryPlanes::ingested_QKE ( ) const

inline

48 {return is_QKE_read;}

◆ ingested_scalar()

int ReadBndryPlanes::ingested_scalar ( ) const

inline

44 {return is_scalar_read;}

◆ ingested_theta()

int ReadBndryPlanes::ingested_theta ( ) const

inline

42 {return (is_temperature_read || is_theta_read);}

◆ ingested_velocity()

int ReadBndryPlanes::ingested_velocity ( ) const

inline

41 {return is_velocity_read;}

◆ interp_in_time()

Vector< std::unique_ptr< PlaneVector > > & ReadBndryPlanes::interp_in_time ( const amrex::Real & time )

Function in ReadBndryPlanes class for interpolating boundary data in time.

Parameters

time	Constant specifying the time for interpolation

 {
     AMREX_ALWAYS_ASSERT(m_tn <= time && time <= m_tnp2);
  
     //Print() << "interp_in_time at time " << time << " given " << m_tn << " " << m_tnp1 << " " << m_tnp2 << std::endl;
     //Print() << "m_tinterp " << m_tinterp << std::endl;
  
     if (time == m_tinterp) {
         // We have already interpolated to this time
         return m_data_interp;
  
     } else {
  
         // We must now interpolate to a new time
         m_tinterp = time;
  
         if (time < m_tnp1) {
             for (OrientationIter oit; oit != nullptr; ++oit) {
                 auto ori = oit();
                 if (ori.coordDir() < 2) {
                     const int nlevels = m_data_n[ori]->size();
                     for (int lev = 0; lev < nlevels; ++lev) {
                         const auto& datn   = (*m_data_n[ori])[lev];
                         const auto& datnp1 = (*m_data_np1[ori])[lev];
                         auto& dati = (*m_data_interp[ori])[lev];
                         dati.linInterp<RunOn::Device>(
                             datn, 0, datnp1, 0, m_tn, m_tnp1, m_tinterp, datn.box(), 0, dati.nComp());
                     }
                 }
             }
         } else {
             for (OrientationIter oit; oit != nullptr; ++oit) {
                 auto ori = oit();
                 if (ori.coordDir() < 2) {
                     const int nlevels = m_data_n[ori]->size();
                     for (int lev = 0; lev < nlevels; ++lev) {
                         const auto& datnp1 = (*m_data_np1[ori])[lev];
                         const auto& datnp2 = (*m_data_np2[ori])[lev];
                         auto& dati = (*m_data_interp[ori])[lev];
                         dati.linInterp<RunOn::Device>(
                             datnp1, 0, datnp2, 0, m_tnp1, m_tnp2, m_tinterp, datnp1.box(), 0,
                             dati.nComp());
                     }
                 }
             }
         }
     }
     return m_data_interp;
 }

◆ read_file()

void ReadBndryPlanes::read_file	(	int	idx,
		amrex::Vector< std::unique_ptr< PlaneVector >> &	data_to_fill,
		amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max >	m_bc_extdir_vals
	)

Function in ReadBndryPlanes to read boundary data for each face and variable from files.

Parameters

idx	Specifies the index corresponding to the timestep we want
data_to_fill	Container for face data on boundaries
m_bc_extdir_vals	Container storing the external dirichlet boundary conditions we are reading from the input files

 {
     const int t_step = m_in_timesteps[idx];
     const std::string chkname1 = m_filename + Concatenate("/bndry_output", t_step);
  
     const std::string level_prefix = "Level_";
     const int lev = 0;
  
     const Box& domain = m_geom.Domain();
     BoxArray ba(domain);
     DistributionMapping dm{ba};
  
     GpuArray<GpuArray<Real, AMREX_SPACEDIM*2>, AMREX_SPACEDIM+NVAR_max> l_bc_extdir_vals_d;
  
     for (int i = 0; i < BCVars::NumTypes; i++)
     {
         for (OrientationIter oit; oit != nullptr; ++oit) {
             auto ori = oit();
             l_bc_extdir_vals_d[i][ori] = m_bc_extdir_vals[i][ori];
         }
     }
  
     int n_for_density = -1;
     for (int i = 0; i < m_var_names.size(); i++)
     {
        if (m_var_names[i] == "density") n_for_density = i;
     }
  
     // We need to initialize all the components because we may not fill all of them from files,
     //    but the loop in the interpolate routine goes over all the components anyway
     int ncomp_for_bc = BCVars::NumTypes;
     for (OrientationIter oit; oit != nullptr; ++oit) {
         auto ori = oit();
         if (ori.coordDir() < 2) {
             FArrayBox& d = (*data_to_fill[ori])[lev];
             const auto& bx = d.box();
             Array4<Real> d_arr = d.array();
             ParallelFor(
                 bx, ncomp_for_bc, [=] AMREX_GPU_DEVICE(int i, int j, int k, int n) noexcept {
                 d_arr(i,j,k,n) = 0.;
             });
         }
     }
  
     // Read density for primitive to conserved conversions
     std::string filenamer = MultiFabFileFullPrefix(lev, chkname1, level_prefix, "density");
     BndryRegister bndry_r(ba, dm, m_in_rad, m_out_rad, m_extent_rad, 1);
     bndry_r.setVal(1.0e13);
     for (OrientationIter oit; oit != nullptr; ++oit) {
           auto ori = oit();
           if (ori.coordDir() < 2) {
               std::string facenamer = Concatenate(filenamer + '_', ori, 1);
               bndry_r[ori].read(facenamer);
           }
     }
  
     for (int ivar = 0; ivar < m_var_names.size(); ivar++)
     {
         std::string var_name = m_var_names[ivar];
  
         std::string filename1 = MultiFabFileFullPrefix(lev, chkname1, level_prefix, var_name);
  
         int ncomp;
         if (var_name == "velocity") {
             ncomp = AMREX_SPACEDIM;
         } else {
             ncomp = 1;
         }
  
         int n_offset;
         if (var_name == "density")     n_offset = BCVars::Rho_bc_comp;
         if (var_name == "theta")       n_offset = BCVars::RhoTheta_bc_comp;
         if (var_name == "temperature") n_offset = BCVars::RhoTheta_bc_comp;
         if (var_name == "ke")          n_offset = BCVars::RhoKE_bc_comp;
         if (var_name == "qke")         n_offset = BCVars::RhoQKE_bc_comp;
         if (var_name == "scalar")      n_offset = BCVars::RhoScalar_bc_comp;
         if (var_name == "qv")          n_offset = BCVars::RhoQ1_bc_comp;
         if (var_name == "qc")          n_offset = BCVars::RhoQ2_bc_comp;
         if (var_name == "velocity")    n_offset = BCVars::xvel_bc;
  
         // Print() << "Reading " << chkname1 << " for variable " << var_name << " with n_offset == " << n_offset << std::endl;
  
         BndryRegister bndry(ba, dm, m_in_rad, m_out_rad, m_extent_rad, ncomp);
         bndry.setVal(1.0e13);
  
         // *********************************************************
         // Read in the BndryReg for all non-z faces
         // *********************************************************
         for (OrientationIter oit; oit != nullptr; ++oit) {
           auto ori = oit();
           if (ori.coordDir() < 2) {
  
             std::string facename1 = Concatenate(filename1 + '_', ori, 1);
             bndry[ori].read(facename1);
  
             const int normal = ori.coordDir();
             const IntVect v_offset = offset(ori.faceDir(), normal);
  
             const auto& bbx = (*data_to_fill[ori])[lev].box();
  
             // *********************************************************
             // Copy from the BndryReg into a MultiFab then use copyTo
             //     to write from the MultiFab to a single FAB for each face
             // *********************************************************
             MultiFab bndryMF(
                 bndry[ori].boxArray(), bndry[ori].DistributionMap(),
                 ncomp, 0, MFInfo());
  
             for (MFIter mfi(bndryMF); mfi.isValid(); ++mfi) {
  
                 const auto& vbx = mfi.validbox();
                 const auto& bndry_read_arr   = bndry[ori].array(mfi);
                 const auto& bndry_read_r_arr = bndry_r[ori].array(mfi);
                 const auto& bndry_mf_arr     = bndryMF.array(mfi);
  
                 const auto& bx = bbx & vbx;
                 if (bx.isEmpty()) {
                     continue;
                 }
  
                 // We average the two cell-centered data points in the normal direction
                 //    to define a Dirichlet value on the face itself.
  
                 // This is the scalars -- they all get multiplied by rho, and in the case of
                 //   reading in temperature, we must convert to theta first
                 Real rdOcp = m_rdOcp;
                 if (n_for_density >= 0) {
                   if (var_name == "temperature") {
                     ParallelFor(
                         bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                              Real R1 =  bndry_read_r_arr(i, j, k, 0);
                              Real R2 =  bndry_read_r_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2],0);
                              Real T1 =  bndry_read_arr(i, j, k, 0);
                              Real T2 =  bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2],0);
                              Real Th1 = getThgivenRandT(R1,T1,rdOcp);
                              Real Th2 = getThgivenRandT(R2,T2,rdOcp);
                              bndry_mf_arr(i, j, k, 0) = 0.5 * (R1*Th1 + R2*Th2);
                         });
                   } else if (var_name == "scalar" || var_name == "qv" || var_name == "qc" ||
                              var_name == "ke"     || var_name == "qke") {
                     ParallelFor(
                         bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                              Real R1 =  bndry_read_r_arr(i, j, k, 0);
                              Real R2 =  bndry_read_r_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2],0);
                              bndry_mf_arr(i, j, k, 0) = 0.5 *
                                   ( R1 * bndry_read_arr(i, j, k, 0) +
                                     R2 * bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2], 0));
                         });
                    } else if (var_name == "density") {
                     ParallelFor(
                         bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                              bndry_mf_arr(i, j, k, 0) = 0.5 *
                                   ( bndry_read_arr(i, j, k, 0) +
                                     bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2], 0));
                         });
                    }
                 } else if (!ingested_density()) {
                   if (var_name == "temperature") {
                     ParallelFor(
                         bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                              Real R1  = l_bc_extdir_vals_d[BCVars::Rho_bc_comp][ori];
                              Real R2  = l_bc_extdir_vals_d[BCVars::Rho_bc_comp][ori];
                              Real T1  = bndry_read_arr(i, j, k, 0);
                              Real T2  = bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2], 0);
                              Real Th1 = getThgivenRandT(R1,T1,rdOcp);
                              Real Th2 = getThgivenRandT(R2,T2,rdOcp);
                              bndry_mf_arr(i, j, k, 0) = 0.5 * (R1*Th1 + R2*Th2);
                         });
                   } else if (var_name == "scalar" || var_name == "qv" || var_name == "qc" ||
                              var_name == "ke"     || var_name == "qke") {
                       ParallelFor(
                         bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                              Real R1  = l_bc_extdir_vals_d[BCVars::Rho_bc_comp][ori];
                              Real R2  = l_bc_extdir_vals_d[BCVars::Rho_bc_comp][ori];
                              bndry_mf_arr(i, j, k, 0) = 0.5 *
                                 (R1 * bndry_read_arr(i, j, k, 0) +
                                  R2 * bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2], 0));
                         });
                   }
                 }
  
                 // This is velocity
                 if (var_name == "velocity") {
                     ParallelFor(
                         bx, ncomp, [=] AMREX_GPU_DEVICE(int i, int j, int k, int n) noexcept {
                                 bndry_mf_arr(i, j, k, n) = 0.5 *
                                   (bndry_read_arr(i, j, k, n) +
                                    bndry_read_arr(i+v_offset[0],j+v_offset[1],k+v_offset[2], n));
                         });
                 }
  
             } // mfi
             bndryMF.copyTo((*data_to_fill[ori])[lev], 0, n_offset, ncomp);
           } // coordDir < 2
         } // ori
     } // var_name
 }

Referenced by read_input_files().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_input_files()

void ReadBndryPlanes::read_input_files	(	amrex::Real	time,
		amrex::Real	dt,
		amrex::Array< amrex::Array< amrex::Real, AMREX_SPACEDIM *2 >, AMREX_SPACEDIM+NVAR_max >	m_bc_extdir_vals
	)

Function in ReadBndryPlanes for reading boundary data at a specific time and at the next timestep from input files.

Parameters

time	Current time
dt	Current timestep
m_bc_extdir_vals	Container storing the external dirichlet boundary conditions we are reading from the input files

 {
     BL_PROFILE("ERF::ReadBndryPlanes::read_input_files");
  
     // Assert that both the current time and the next time are within the bounds
     // of the data that we can read
     AMREX_ALWAYS_ASSERT((m_in_times[0] <= time) && (time <= m_in_times.back()));
     AMREX_ALWAYS_ASSERT((m_in_times[0] <= time+dt) && (time+dt <= m_in_times.back()));
  
     int ncomp = 1;
  
     const Box& domain = m_geom.Domain();
     BoxArray ba(domain);
     DistributionMapping dm{ba};
     BndryRegister bndryn(ba, dm, m_in_rad, m_out_rad, m_extent_rad, ncomp);
     bndryn.setVal(1.0e13);
  
     // The first time we enter this routine we read the first three files
     if (last_file_read == -1)
     {
         int idx_init = 0;
         read_file(idx_init,m_data_n,m_bc_extdir_vals);
         read_file(idx_init,m_data_interp,m_bc_extdir_vals); // We want to start with this filled
         m_tn = m_in_times[idx_init];
  
         idx_init = 1;
         read_file(idx_init,m_data_np1,m_bc_extdir_vals);
         m_tnp1 = m_in_times[idx_init];
  
         idx_init = 2;
         read_file(idx_init,m_data_np2,m_bc_extdir_vals);
         m_tnp2 = m_in_times[idx_init];
  
         last_file_read = idx_init;
     }
  
     // Compute the index such that time falls between times[idx] and times[idx+1]
     const int idx = closest_index(m_in_times, time);
  
     // Now we need to read another file
     if (idx >= last_file_read-1 && last_file_read != m_in_times.size()-1) {
         int new_read = last_file_read+1;
  
         // We need to change which data the pointers point to before we read in the new data
         // This doesn't actually move the data, just swaps the pointers
         for (OrientationIter oit; oit != nullptr; ++oit) {
             auto ori = oit();
             std::swap(m_data_n[ori]  ,m_data_np1[ori]);
             std::swap(m_data_np1[ori],m_data_np2[ori]);
         }
  
         // Set the times corresponding to the post-swap pointers
         m_tn   = m_tnp1;
         m_tnp1 = m_tnp2;
         m_tnp2 = m_in_times[new_read];
  
         read_file(new_read,m_data_np2,m_bc_extdir_vals);
         last_file_read = new_read;
     }
  
     AMREX_ASSERT(time    >= m_tn && time    <= m_tnp2);
     AMREX_ASSERT(time+dt >= m_tn && time+dt <= m_tnp2);
 }

Here is the call graph for this function:

◆ read_time_file()

void ReadBndryPlanes::read_time_file ( )

Function in ReadBndryPlanes class for reading the external file specifying time data and broadcasting this data across MPI ranks.

 {
     BL_PROFILE("ERF::ReadBndryPlanes::read_time_file");
  
     // *********************************************************
     // Read the time.data file and store the timesteps and times
     // *********************************************************
     int time_file_length = 0;
  
     if (ParallelDescriptor::IOProcessor()) {
  
         std::string line;
         std::ifstream time_file(m_time_file);
         if (!time_file.good()) {
             Abort("Cannot find time file: " + m_time_file);
         }
         while (std::getline(time_file, line)) {
             ++time_file_length;
         }
  
         time_file.close();
     }
  
     ParallelDescriptor::Bcast(
         &time_file_length, 1,
         ParallelDescriptor::IOProcessorNumber(),
         ParallelDescriptor::Communicator());
  
     m_in_times.resize(time_file_length);
     m_in_timesteps.resize(time_file_length);
  
     if (ParallelDescriptor::IOProcessor()) {
         std::ifstream time_file(m_time_file);
         for (int i = 0; i < time_file_length; ++i) {
             time_file >> m_in_timesteps[i] >> m_in_times[i];
         }
         // Sanity check that there are no duplicates or mis-orderings
         for (int i = 1; i < time_file_length; ++i) {
             if (m_in_timesteps[i] <= m_in_timesteps[i-1])
                 Error("Bad timestep in time.dat file");
             if (m_in_times[i] <= m_in_times[i-1])
                 Error("Bad time in time.dat file");
         }
         time_file.close();
     }
  
     ParallelDescriptor::Bcast(
         m_in_timesteps.data(), time_file_length,
         ParallelDescriptor::IOProcessorNumber(),
         ParallelDescriptor::Communicator());
  
     ParallelDescriptor::Bcast(
         m_in_times.data(), time_file_length,
         ParallelDescriptor::IOProcessorNumber(),
         ParallelDescriptor::Communicator());
  
     // Allocate data we will need -- for now just at one level
     int lev = 0;
     define_level_data(lev);
     Print() << "Successfully read time file and allocated data" << std::endl;
 }