Trait RONImportParallel 

pub trait RONImportParallel<'a, C: Communicator + 'a>: Sized + ParallelGrid<C = C>
where
    Self::LocalGrid: RONImport,
    Self: 'a,
{
    // Required method
    fn create_from_ron_info(comm: &'a C, local_grid: Self::LocalGrid) -> Self;

    // Provided method
    fn import_from_ron(comm: &'a C, filename: &str) -> Self { ... }
}

Parallel grid import for RON

Required Methods

fn create_from_ron_info(comm: &'a C, local_grid: Self::LocalGrid) -> Self

Create parallel grid from comm and local_grid

Provided Methods

fn import_from_ron(comm: &'a C, filename: &str) -> Self

Export as RON

Examples found in repository

ndgrid/examples/test_parallel_io.rs (lines 64-66)

fn test_parallel_import<C: Communicator>(comm: &C) {
    use ndgrid::traits::ParallelGrid;

    let size = comm.size();

    let filename = format!("_examples_parallel_io_{size}ranks.ron");
    let grid =
        ParallelGridImpl::<'_, C, SingleElementGrid<f64, CiarletElement<f64, IdentityMap>>>::import_from_ron(
            comm, &filename,
        );

    let n = 10;
    let grid2 = example_single_element_grid(comm, n);

    assert_eq!(
        grid.local_grid().entity_count(ReferenceCellType::Point),
        grid2.local_grid().entity_count(ReferenceCellType::Point)
    );
}

ndgrid/examples/parallel_io.rs (line 40)

fn main() {
    let universe: Universe = mpi::initialize().unwrap();
    let comm = universe.world();
    let rank = comm.rank();

    let g = if rank == 0 {
        // Create a grid using the shapes module: unit_cube_boundary will mesh the surface of a cube
        let serial_g = shapes::unit_cube_boundary::<f64>(4, 5, 4, ReferenceCellType::Triangle);

        // Distribute this grid across processes
        serial_g.distribute(&comm, GraphPartitioner::None)
    } else {
        let b = SingleElementGridBuilder::<f64>::new(3, (ReferenceCellType::Triangle, 1));
        b.create_parallel_grid(&comm, 0)
    };

    // If the serde option is used, the raw grid data can be exported in RON format
    g.export_as_ron("_unit_cube_boundary_parallel.ron");

    // Wait for export to finish
    comm.barrier();

    // A grid can be re-imported from raw RON data. Note that it must be imported on the same number of processes as it was exported using
    let g2 = ParallelGridImpl::<'_, _, SingleElementGrid::<f64, CiarletElement<f64, IdentityMap>>>::import_from_ron(&comm, "_unit_cube_boundary_parallel.ron");

    // Print the first 5 cells of each grid on process 0
    if rank == 0 {
        println!("The first 5 cells of the grids");
        for (cell, cell2) in izip!(
            g.local_grid().entity_iter(ReferenceCellType::Triangle),
            g2.local_grid().entity_iter(ReferenceCellType::Triangle)
        )
        .take(5)
        {
            println!(
                "{:?} {:?}",
                cell.topology()
                    .sub_entity_iter(ReferenceCellType::Point)
                    .collect::<Vec<_>>(),
                cell2
                    .topology()
                    .sub_entity_iter(ReferenceCellType::Point)
                    .collect::<Vec<_>>(),
            );
        }
    }
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, EntityDescriptor, C: Communicator + 'a, G: Grid<EntityDescriptor = EntityDescriptor> + Sync + ConvertToSerializable> RONImportParallel<'a, C> for ParallelGridImpl<'a, C, G>

where for<'de2> <G as ConvertToSerializable>::SerializableType: Deserialize<'de2>, for<'de2> EntityDescriptor: Deserialize<'de2> + Debug + PartialEq + Eq + Clone + Copy + Hash + Serialize, Self: 'a,

Available on crate feature serde only.