Hi Wolfgang. Thanks for this. Please see my comments below.
>
>> my only concern with this approach is what occurs if children have
>> children? Because a cell has children need not mean it has been refined
>> during this refinement step (I think). I guess the criteria would be that
>> the children are active (ie no children)?
>
> Yes, sorry, that's of course the correct criterion.
>
>
>> If you coarsen a mesh does the coarsened cell still have children?
>
> You mean the parent cell whose children have been removed? No.
OK
>
>
>> the coarsening part is less obvious to me.
>> i have the cells to be coarsened in a vector, the objective is now to find
>> their parents. I can loop over all cells and check to see if their children
>> are in the cells to be coarsened. Of coarse this only makes sense if a
>> coarsened cell has children after refinement. If not then I would need to
>> loop over the triangulation prior to executing the refinement.
>
> That's indeed the case.
>
> By the way, you are aware of the SolutionTransfer class, right?
Yes. I wish I could use it...
The problem is I'm trying to use adaptivity for problems where there are
internal variables stored at the level of the quadrature point. I make use of
the data structures presented in tut 18:
PointHistory: class to store quadrature point
data
quadrature_point_history: std::vector of PointHistory
cell->user_pointer: set to point to a position in
the quadrature_point_history std::vector.
Deal.ii is designed with nodal data in mind.
A really neat extension would be to make the PointHistory class a part of
deal.ii. So each cell would have a (pointer to a) std::vector of PointHistory.
One would then provide the PointHistory base class with a virtual function that
describes how to project quadrature point data upon coarsening / refinement.
The projection matrix is already well defined (as mentioned in tut 18). All the
built in machinery for mesh adaptivity could then be utilised to project
quadrature point data between meshes.
The next challenge is reconstructing the std::vector quadrature_point_history
between refinement steps. This is a non-issue if each cell has a std::vector of
PointHistory to hold the quadrature point data. Thus one could extend it to
parallel problems.
We are quite keen to try and implement such a structure as it would be of huge
value in solid mechanics.
Any thoughts on this?
Andrew
>
> W.
>
> -------------------------------------------------------------------------
> Wolfgang Bangerth email: [email protected]
> www: http://www.math.tamu.edu/~bangerth/
>
_______________________________________________
dealii mailing list http://poisson.dealii.org/mailman/listinfo/dealii
