Dear Users,
We are writing a multiphysics tool where we need to replicate a FD mesh in a FE
way. We have been almost able to translate one into the other but are facing
some minor difficulties (hopefully).
I would greatly appreciate if someone could help us find the missing steps for
having a complete mesh.
We need to build/replicate the mesh from scratch in parallel (distributed mesh)
because due to the nature of a FD grid it has ~10^8 or more grid points
What we HAVE:
- functions that uniquely assign a node ID to each FD grid point (locally as
well as globally contiguously across processes, uniquely, 0-based)
- functions that assign these nodes to elements (we support TRI3, QUAD4, TET4,
HEX8) 2/3D respectively.
- functions that uniquely assign an element ID to each element (locally as well
as globally contiguously across processes, uniquely, 0-based)
- to copy the mesh we do:
- loop over element’s and their nodes and add their nodes if they are
not already added by:
- building a node (with the coordinates, and global ID)
- setting processor_id() (not necessarily the one that this is
done on)
- setting unique_id
- adding node
- loop over elements and add them by:
- building element
- setting processor_id()
- setting id
- setting unique_id
- setting nodes (with loop over nodes)
- adding element
- them we call the following functions:
mesh.partitioner() = NULL;
mesh.allow_renumbering(false);
mesh.skip_partitioning(true);
MeshCommunication().gather_neighboring_elements(cast_ref<DistributedMesh
&>(mesh));
mesh.prepare_for_use(/*skip_renumber_nodes_and_elements=*/
true, /*skip_find_neighbors=*/false);
This will create a mesh that looks ok if printed but trips assertions in debug
mode.
What we DON’T HAVE:
- A clear understanding of how ghost elements in LibMesh work.
- Knowledge about the difference of ghost and semilocal elements.
- A clear outline of operations to perform in order to set up such a parallel
mesh with the availability of the above mentioned functions for numbering.
A note on this: The above mentioned functions create elements across
the entire FD grid also such element that span across processor boundaries. If
I read them in like that will
Libmesh be able to find out about which of them
are ghost elements just by knowing that their vertices are not all on the same
processor (e.g. after calling prepare_for_use).
If this is not the case how exactly would I go
about telling this kind of information to Libmesh?
I come from a FD background and am currently gaining knowledge on all types of
FE codes, so excuse me for any obvious points that I might have missed.
I appreciate your help!
–Barna
<https://www.youtube.com/channel/UCQiVLRF9ub-T8sW-RKIULMA>
------------------------------------------------------------------------------
Developer Access Program for Intel Xeon Phi Processors
Access to Intel Xeon Phi processor-based developer platforms.
With one year of Intel Parallel Studio XE.
Training and support from Colfax.
Order your platform today. http://sdm.link/xeonphi
_______________________________________________
Libmesh-users mailing list
Libmesh-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/libmesh-users
