I will try to be as short as possible - if more details are required feel 
free to ask. Also I offer to submit all mesh generation code I create in 
the future, since others might have similar needs at some point.

I work on a 3d mesh with purely axis-parallel edges. The mesh is a 2d-mesh 
(say in x and y direction) extruded to 3d (z-direction). Due to the scheme 
I use it is required, that the distributed version of this mesh be 
distributed as intervals along the z-axis ( process 0 has all cells with 
cell->center()[2] in [0,1], process 1 has all cells with cell->center()[2] 
in (1,2] and so on.)
What I did originally was simply generating a mesh consisting of 
n_processes cells, let that mesh be auto partitioned, then turning 
partitioning off and then using global refinement of marked cells to 
generate the right structure inside these cells for each processor. This 
however feels like a very elaborate workaround and the lack of anisotropic 
refinement for distributed meshes is a heavy restriction here. However, 
this seemed to be a feasible workaround for the time being.
Recently a new problem has arisen however: For the construction of a 
blockwise, parallel preconditioner for a sweeping method I now need 
codimension 1 meshes of the process-to-process mesh-interfaces (again a 
simple copy of the theoretical 2D-mesh, which was extruded to generate the 
3d mesh, if that were possible) because I need nodal and Nedelec-elements 
on these 2D-interfaces for the computation of some integrals.
So my questions would be:
1. given a 2D-mesh, what is the easiest way to get a distributed 
3d-extrusion with the partitioning described above?  (auto-partitioning 
generates balls in this mesh, not cuboids with z-orthogonal 
process-to-process interfaces) One suggestion for a function here would be 
a function to transform a shared to a distributed mesh because on a shared 
mesh I could set the subdomain Ids and then just call that function when 
I'm done
2. say I have a layer of faces in that mesh (in the interior) and I need 
nedelec elements and nodal elements on these faces (codimension 1) to 
evaluate their shape function and gradients in quadrature points of a 
2D-quadrature on the faces. What is the best way to do this? (if it was a 
boundary I could give a boundary id and call 
GridGenerator::extract_boundary_mesh but it's not always on the boundary.
3. There is a description on how to manually generate a mesh which seems 
easy enough in my case. How does this work for a distributed mesh? Is the 
only version to generate a mesh and then auto-partition or can I somehow 
define the partitioning in the generation phase similar to the way I could 
set subdomain Ids in a shared parallel mesh?
4. What can I do to extend the exising functionality? Since the memory 
consumtion of my (and most likely most codes) is low during mesh 
generation, first generating a shared mesh and then distributing it would 
not be a problem (compared to keeping the shared mesh during computation 
when the matrices and vectors also take up a lot of the memory). Do you 
consider such a function "easy" to implement?

Thank you for your time!
Pascal


-- 
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to