internal Namespace Reference

Functions
void	initial_fluxes (int nz, int nlay, int nbands, FluxesByband &fluxes)
void	expand_day_fluxes (const FluxesByband &daytime_fluxes, FluxesByband &expanded_fluxes, const int1d &day_indices)
void	reordered (const real1d &array_in, const int1d &new_indexing, const real1d &array_out)

Function Documentation

expand_day_fluxes()

void internal::expand_day_fluxes	(	const FluxesByband &	daytime_fluxes,
		FluxesByband &	expanded_fluxes,
		const int1d &	day_indices
	)

    {
        auto ncol  = size(daytime_fluxes.bnd_flux_up, 1);
        auto nlev  = size(daytime_fluxes.bnd_flux_up, 2);
        auto nbnds = size(daytime_fluxes.bnd_flux_up, 3);
 
        int1d nday_1d("nday_1d", 1),nday_host("nday_host",1);
        yakl::memset(nday_1d, 0);
        parallel_for(SimpleBounds<1>(ncol), YAKL_LAMBDA (int icol)
        {
            if (day_indices(icol) > 0) nday_1d(1)++;
            //printf("daynight indices(check): %d, %d, %d\n",icol,day_indices(icol),nday_1d(1));
        });
 
        nday_1d.deep_copy_to(nday_host);
        auto nday = nday_host(1);
        AMREX_ASSERT_WITH_MESSAGE((nday>0) && (nday<=ncol), "RADIATION: Invalid number of days!");
        parallel_for(SimpleBounds<3>(nday, nlev, nbnds), YAKL_LAMBDA (int iday, int ilev, int ibnd)
        {
            // Map daytime index to proper column index
            auto icol = day_indices(iday);
            //auto icol = iday;
            // Expand broadband fluxes
            expanded_fluxes.flux_up(icol,ilev)     = daytime_fluxes.flux_up(iday,ilev);
            expanded_fluxes.flux_dn(icol,ilev)     = daytime_fluxes.flux_dn(iday,ilev);
            expanded_fluxes.flux_net(icol,ilev)    = daytime_fluxes.flux_net(iday,ilev);
            expanded_fluxes.flux_dn_dir(icol,ilev) = daytime_fluxes.flux_dn_dir(iday,ilev);
 
            // Expand band-by-band fluxes
            expanded_fluxes.bnd_flux_up(icol,ilev,ibnd)     = daytime_fluxes.bnd_flux_up(iday,ilev,ibnd);
            expanded_fluxes.bnd_flux_dn(icol,ilev,ibnd)     = daytime_fluxes.bnd_flux_dn(iday,ilev,ibnd);
            expanded_fluxes.bnd_flux_net(icol,ilev,ibnd)    = daytime_fluxes.bnd_flux_net(iday,ilev,ibnd);
            expanded_fluxes.bnd_flux_dn_dir(icol,ilev,ibnd) = daytime_fluxes.bnd_flux_dn_dir(iday,ilev,ibnd);
        });
    }

Referenced by Radiation::radiation_driver_sw().

Here is the caller graph for this function:

initial_fluxes()

void internal::initial_fluxes	(	int	nz,
		int	nlay,
		int	nbands,
		FluxesByband &	fluxes
	)

    {
        fluxes.flux_up     = real2d("flux_up"    , nz, nlay+1);
        fluxes.flux_dn     = real2d("flux_dn"    , nz, nlay+1);
        fluxes.flux_net    = real2d("flux_net"   , nz, nlay+1);
        fluxes.flux_dn_dir = real2d("flux_dn_dir", nz, nlay+1);
 
        fluxes.bnd_flux_up     = real3d("flux_up"    , nz, nlay+1, nbands);
        fluxes.bnd_flux_dn     = real3d("flux_dn"    , nz, nlay+1, nbands);
        fluxes.bnd_flux_net    = real3d("flux_net"   , nz, nlay+1, nbands);
        fluxes.bnd_flux_dn_dir = real3d("flux_dn_dir", nz, nlay+1, nbands);
    }

Referenced by Radiation::radiation_driver_sw(), and Radiation::run().

Here is the caller graph for this function:

reordered()

void internal::reordered	(	const real1d &	array_in,
		const int1d &	new_indexing,
		const real1d &	array_out
	)

    {
        // Reorder array based on input index mapping, which maps old indices to new
        parallel_for(SimpleBounds<1>(size(array_in, 1)), YAKL_LAMBDA (int i)
        {
            array_out(i) = array_in(new_indexing(i));
        });
    }

Referenced by Radiation::run().

Here is the caller graph for this function: