Method SyncCurrent

Source/Parallelization/WarpXComm.cpp:1169–1344

}

void
WarpX::SyncCurrent (const std::string& current_fp_string)
{
    using ablastr::fields::Direction;

    ABLASTR_PROFILE("WarpX::SyncCurrent()");

    bool const skip_lev0_coarse_patch = true;

    ablastr::fields::MultiLevelVectorField const& J_fp = m_fields.get_mr_levels_alldirs(current_fp_string, finest_level);

    // If warpx.do_current_centering = 1, center currents from nodal grid to staggered grid
    if (do_current_centering)
    {
        ablastr::fields::MultiLevelVectorField const& J_fp_nodal = m_fields.get_mr_levels_alldirs(FieldType::current_fp_nodal, finest_level);

        AMREX_ALWAYS_ASSERT_WITH_MESSAGE(finest_level <= 1,
                                         "warpx.do_current_centering=1 not supported with more than one fine levels");
        for (int lev = 0; lev <= finest_level; lev++)
        {
            constexpr auto all_dirs = std::array{Direction{0}, Direction{1}, Direction{2}};
            for (const auto& dir : all_dirs){
                ::UpdateCurrentNodalToStag(
                    *J_fp[lev][dir], *J_fp_nodal[lev][dir],
                    m_current_centering_nox, m_current_centering_noy, m_current_centering_noz,
                    device_current_centering_stencil_coeffs_x,
                    device_current_centering_stencil_coeffs_y,
                    device_current_centering_stencil_coeffs_z);
            }
        }
    }

    // If there is a single level, we apply the filter on the fp data and
    // then call SumBoundary that adds data from different boxes. This needs
    // to be done because a particle near a box boundary may deposit current
    // at a given (i,j,k) that is on the edge or in the ghost region of that
    // box while at the same time that (i,j,k) is also in the valid region
    // of another box. After SumBoundary, the result is as if there is only
    // a single box on a single process. Also note we need to call
    // SumBoundary even if there is only a single process, because a process
    // may have multiple boxes. Furthermore, even if there is only a single
    // box on a single process, SumBoundary should also be called if there
    // are periodic boundaries. So we always call SumBoundary even if it
    // might be a no-op in some cases, because the function does not perform
    // any communication if not necessary.
    //
    // When there are multiple levels, we need to send data from fine levels
    // to coarse levels. In the implementation below, we loop over levels
    // from the finest to the coarsest. On each level, filtering and
    // SumBoundary are done as the last two things. So the communication
    // data on the sender side are always unfiltered and unsummed. The
    // receivers are responsible for filtering that is dependent on the grid
    // resolution. On the finest level, we coarsen the unsummed fp data onto
    // cp grids, which are the coarsened version of the fp grids with the
    // same DistributionMapping. Then on the level below, We use ParallelAdd
    // to add the finer level's cp data onto the current level's fp
    // data. After that, we apply filter and SumBoundary to the finer
    // level's cp MultiFab. At this time, the finer level's fp and cp data