The tool I work on here at work can compare any two arbitrary
solutions to each other... even with completely non-nested grids.  The
user gets to decide what kind of crime they want to commit though.
Often (if the meshes are really dissimilar) we'll use an overkill
rendezvous mesh to transfer both of the original solutions to first...
then compare them on that grid. (Note: To do this in libMesh use two
MeshFunctions and 3 meshes)

My favorite way though... is just to lay down a super fine quadrature
rule and sample both grids at those quadrature points.  Sure... on one
of the meshes you'll be integrating non-smooth functions with Gauss
quadrature... but the results are usually pretty good.

I do think that some of the capabilities in this code at my current
job are going to be put into libMesh over the next year.  libMesh
already has a lot of the infrastructure for it... it wouldn't be too
hard to make it a little more generic.

Derek

On Wed, Apr 16, 2008 at 8:12 AM, John Peterson <[EMAIL PROTECTED]> wrote:
> On Wed, Apr 16, 2008 at 8:15 AM, Roy Stogner <[EMAIL PROTECTED]> wrote:
>  >
>  >  On Wed, 16 Apr 2008, Tim Kroeger wrote:
>  >
>  >  > Next question from me: Is there some easy way in libMesh to compare
>  >  > computation results on different grids?  I.e., I have two
>  >  > EquationSystems instances that consist of equal systems but live on
>  >  > different grids, where both grids are refinements of the same initial
>  >  > grid.  For each variable in each system, I want the difference of the
>  >  > computed solutions on the two grids, in various norms (say L1, L2,
>  >  > Linfty).
>  >  >
>  >  > I conjecture that there is no easy way to do this in libMesh, but I
>  >  > thought it might be sensible to ask.
>  >
>  >  If by "different" you mean that one mesh is everywhere as fine as or
>  >  finer than the other, then you can construct a MeshFunction from the
>  >  coarser solution and use it with an ExactSolution object on the fine
>  >  system to get the right answer.
>  >
>  >  If one grid is finer in some places and the other grid is finer in
>  >  others then there's currently no way to do this precisely.  You might
>  >  use the ExactSolution trick on a "mostly finer" grid with an overkill
>  >  quadrature rule to get something close enough, but the right thing to
>  >  do here would require new code.
>  >
>
>  Just out of curiosity, what would be the "right thing" to do in order
>  to compare two meshes with different (still nested) refinement
>  patterns or two solutions on completely non-nested grids?  It's not
>  immediately obvious to me what such a comparison would actually tell
>  you in any case...
>
>  -J
>
>
>
>  -------------------------------------------------------------------------
>  This SF.net email is sponsored by the 2008 JavaOne(SM) Conference
>  Don't miss this year's exciting event. There's still time to save $100.
>  Use priority code J8TL2D2.
>  
> http://ad.doubleclick.net/clk;198757673;13503038;p?http://java.sun.com/javaone
>  _______________________________________________
>  Libmesh-users mailing list
>  [email protected]
>  https://lists.sourceforge.net/lists/listinfo/libmesh-users
>

-------------------------------------------------------------------------
This SF.net email is sponsored by the 2008 JavaOne(SM) Conference 
Don't miss this year's exciting event. There's still time to save $100. 
Use priority code J8TL2D2. 
http://ad.doubleclick.net/clk;198757673;13503038;p?http://java.sun.com/javaone
_______________________________________________
Libmesh-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/libmesh-users

Reply via email to