Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-04 14:23 ```Roy Stogner writes: > On Wed, 4 Apr 2007, Luca Antiga wrote: > > > I could live with non zero values on the zero velocity faces, but aren't > > those a bit large (10% of the top face velocity)? > > Yes, but then Gibbs' type ringing usually is large. What's worse: as > you refine the mesh the boundary condition approximation will converge > in the L2 norm, but it can't converge in L_infinity.. > > > I'm just worried that the situation might go out of control in > > complicated geometries, so that's why I'm a bit picky on this > > problem. > > It's not the geometry that's controlling the problem, it's the > discontinuity in the boundary conditions. > I think John's had somewhat smoother results by using an H1 instead > of L2 boundary penalty, but when you try to force a continuous > approximation function to take on discontinuous values, there's > really no good way for it to react. Actually, I couldn't get the H1 projection to work (in 2D). I tried penalizing the tangential derivatives, to e.g. enforce du/dx=dv/dx=0 along the lid. One thing that seemed to help a bit (at least in 2D) was to use the "lumped" L2 projection (e.g. ex13). If memory serves, that solution "looked" slightly better (at least in 2D). > Many people give up and just regularize the problem boundary > conditions. Indeed, the hyperbolic tangent-type regularized boundary conditions seem to be fairly standard in the literature for this type of problem. If we just want to be sure Stokes+AMR+Tets is working, let's try a test problem with continuous data? -J ```

[Libmesh-users] AMR in 3D Lorenzo Botti <bottilorenzo@gm...>
 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-03-31 04:09 ```On Thu, 29 Mar 2007, Lorenzo Botti wrote: > We're testing our solver on the lid driven cavity problem 3D but we're > experiencing some problems, maybe with hanging nodes constraints...? Well, you're not looping over inactive elements, you haven't forgotten to multiply any terms by JxW, you haven't forgotten the constrain_ call before matrix assembly, and you don't have a nonlinear loop combined with inexact constraint enforcement. That exhausts my list of "things I've seen new users do which break adaptivity". All I can suggest now is that you try to simplify the problem as much as possible; I don't think any of us have time to debug something so complicated unless we can be sure it's a library problem. I only do 3D problems on hexes, so you might try running on a hex mesh to see if we have some bug in AMR on tets. I wouldn't bet on it, though; I believe John uses AMR on tets for some of his double-diffusion code. Oh, and if you haven't already, try the latest CVS head and try running with METHOD=dbg, just to see if there are any bugfixes you need or assert() calls you might trip. And, when you do find the problem, even if it's just a user mistake and not a library bug, let us know. If it's something we can prevent in the future by adding more assert() statements that would be nice, and at the very least it might help future users if we had a more complete "things which can break adaptivity" list. --- Roy ```

 [Libmesh-users] AMR in 3D From: Lorenzo Botti - 2007-04-03 15:52 ```Thanks a lot for your time... After your suggestions we've tested our navierstokes solver on the 3D lid driven cavity problem with both hex27 and tet10. Amr works great with hex and the problem we encountered with tet10 is limited to the selection of mesh refinemet levels greater than one. Could this suggest a possible problem in libmesh? We're investigating this... Lorenzo Chiacchiera con i tuoi amici in tempo reale! http://it.yahoo.com/mail_it/foot/*http://it.messenger.yahoo.com ```

 [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-03 16:11 ```Lorenzo Botti writes: > Thanks a lot for your time... > After your suggestions we've tested our navierstokes solver on the 3D > lid driven cavity problem with both hex27 and tet10. > Amr works great with hex and the problem we encountered with tet10 is > limited to the selection of mesh refinemet levels greater than one. > Could this suggest a possible problem in libmesh? We're investigating > this... Hi Lorenzo, There could be a problem with the tets+adaptivity. Tim Kroger recently introduced a new refinement pattern for tetrahedral elements which performs an "edge swap" during refinement to avoid generating small angles. I think this was tested pretty extensively, but I could be wrong. -J ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-04-03 16:13 ```On Tue, 3 Apr 2007, Lorenzo Botti wrote: > After your suggestions we've tested our navierstokes solver on the 3D > lid driven cavity problem with both hex27 and tet10. > Amr works great with hex and the problem we encountered with tet10 is > limited to the selection of mesh refinemet levels greater than one. What do you mean by "mesh refinement levels greater than one"? Relaxing the default level-one hanging node restriction? More than one level of initial uniform refinement? More than one level of AMR on top of a uniform grid? > Could this suggest a possible problem in libmesh? We're > investigating this... I've never done Navier-Stokes with tets; is it possible that tet AMR (with quadratic velocity, linear pressure, I assume) leads to LBB violations? You might see if you can reproduce the problem on a PDE with a positive definite weak form. If it is a libMesh bug, my first instinct would be to doublecheck that the hanging node constraints are being properly created and satisfied. Try the "DiscontinuityMeasure" object to make sure that your interelement jumps on the failing meshes are on the order of machine precision. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-04 12:08 ```Um95LCBKb2huLA0KICB0aGFua3MgZm9yIHRoZSBwcm9tcHQgZm9sbG93IHVwcy4NCiAgSSBy ZXBseSBvbiBMb3JlbnpvJ3MgYmVoYWxmIHNpbmNlIHdlJ3JlIHdvcmtpbmcgdG9nZXRoZXIg YW5kIGhlJ3MgIA0Kb3V0IG9mIHRoZSBvZmZpY2UgdG9kYXkuDQoNCj4gV2hhdCBkbyB5b3Ug bWVhbiBieSAibWVzaCByZWZpbmVtZW50IGxldmVscyBncmVhdGVyIHRoYW4gb25lIj8NCj4g UmVsYXhpbmcgdGhlIGRlZmF1bHQgbGV2ZWwtb25lIGhhbmdpbmcgbm9kZSByZXN0cmljdGlv bj8gIE1vcmUgdGhhbg0KPiBvbmUgbGV2ZWwgb2YgaW5pdGlhbCB1bmlmb3JtIHJlZmluZW1l bnQ/ICBNb3JlIHRoYW4gb25lIGxldmVsIG9mIEFNUg0KPiBvbiB0b3Agb2YgYSB1bmlmb3Jt IGdyaWQ/DQoNCk1vcmUgdGhhbiBvbmUgbGV2ZWwgb2YgQU1SIG9uIHRvcCBvZiBhIHVuaWZv cm0gZ3JpZCwgdGhhdCB3YXMgb3VyIHRlc3QuDQoNCj4gSSd2ZSBuZXZlciBkb25lIE5hdmll ci1TdG9rZXMgd2l0aCB0ZXRzOyBpcyBpdCBwb3NzaWJsZSB0aGF0IHRldCBBTVINCj4gKHdp dGggcXVhZHJhdGljIHZlbG9jaXR5LCBsaW5lYXIgcHJlc3N1cmUsIEkgYXNzdW1lKSBsZWFk cyB0byBMQkINCj4gdmlvbGF0aW9ucz8gIFlvdSBtaWdodCBzZWUgaWYgeW91IGNhbiByZXBy b2R1Y2UgdGhlIHByb2JsZW0gb24gYSBQREUNCj4gd2l0aCBhIHBvc2l0aXZlIGRlZmluaXRl IHdlYWsgZm9ybS4NCg0KWWVzLCBQMlAxIDEwLW5vZGVkIHRldHMsIExCQiBzdGFibGUgKHdp dGhvdXQgQU1SKS4NClRoaXMgaXMgYSBnb29kIHBvaW50LCBob3dldmVyIHdlJ3JlIHNlZWlu ZyBubyBzcHVyaW91cyBwcmVzc3VyZSBtb2Rlcw0KaW4gdGhlIHJlZmluZWQgbWVzaGVzLiBQ bHVzLCBpdCBzZWVtcyB0byB3b3JrIHdpdGggdGhlIGZpcnN0IGxldmVsIG9mICANCnJlZmlu ZW1lbnQuDQpXZSdsbCB0ZXN0IGl0IHdpdGggYSBwb3NpdGl2ZSBkZWZpbml0ZSB3ZWFrIGZv cm0sIHRoYXQncyBhIGdvb2QgaWRlYS4NCg0KQW5vdGhlciB0ZXN0IHdlIHdhbnQgdG8gcGVy Zm9ybSBpcyBpbXBvc2luZyBEaXJpY2hsZXQgYm91bmRhcnkgIA0KY29uZGl0aW9ucw0KdGhl IG9sZCBMYWdyYW5naWFuIHdheSwgYnkgc2V0dGluZyB0aGUgZGlhZ29uYWwgdGVybSB0byAx LCB0aGUgZXh0cmEtIA0KZGlhZ29uYWwNCnRlcm1zIHRvIDAgYW5kIHRoZSByaHMgdG8gdGhl IGJjIHZhbHVlLg0KDQpUaGUgZmFjdCBpcyB0aGF0IG5vIG1hdHRlciB3aGF0IHdlIHRyeSwg aXQgc2VlbXMgd2UncmUgbm90IGFibGUgdG8gIA0KaW1wb3NlIGJvdW5kYXJ5DQpjb25kaXRp b25zIGV4YWN0bHkuIFdlIGFsd2F5cyBzZWUgc3B1cmlvdXMgdmVsb2NpdGllcyBvbiBzaWRl IHdhbGwgIA0KZWxlbWVudHMgaW4gYWxsDQpjaGlsZHJlbiB3aG9zZSBwYXJlbnRzIGFyZSBh ZGphY2VudCB0byB0aGUgdG9wIHdhbGwuDQoNCj4gSWYgaXQgaXMgYSBsaWJNZXNoIGJ1Zywg bXkgZmlyc3QgaW5zdGluY3Qgd291bGQgYmUgdG8gZG91YmxlY2hlY2sgdGhhdA0KPiB0aGUg aGFuZ2luZyBub2RlIGNvbnN0cmFpbnRzIGFyZSBiZWluZyBwcm9wZXJseSBjcmVhdGVkIGFu ZCBzYXRpc2ZpZWQuDQo+IFRyeSB0aGUgIkRpc2NvbnRpbnVpdHlNZWFzdXJlIiBvYmplY3Qg dG8gbWFrZSBzdXJlIHRoYXQgeW91cg0KPiBpbnRlcmVsZW1lbnQganVtcHMgb24gdGhlIGZh aWxpbmcgbWVzaGVzIGFyZSBvbiB0aGUgb3JkZXIgb2YgbWFjaGluZQ0KPiBwcmVjaXNpb24u DQoNCkFub3RoZXIgZ29vZCBzdWdnZXN0aW9uLiBXZSBzdGlsbCBkb24ndCBrbm93IHRoZSBk ZXRhaWxzIG9mIHRoZSBBTVIgIA0KaW1wbGVtZW50YXRpb24NCnVzZWQgaW4gbGlibWVzaC4g V2UncmUgbGVhcm5pbmcgYXMgd2UgZ28uDQoNCj4gVGhlcmUgY291bGQgYmUgYSBwcm9ibGVt IHdpdGggdGhlIHRldHMrYWRhcHRpdml0eS4gIFRpbSBLcm9nZXIgIA0KPiByZWNlbnRseQ0K PiBpbnRyb2R1Y2VkIGEgbmV3IHJlZmluZW1lbnQgcGF0dGVybiBmb3IgdGV0cmFoZWRyYWwg ZWxlbWVudHMgd2hpY2ggIA0KPiBwZXJmb3Jtcw0KPiBhbiAiZWRnZSBzd2FwIiBkdXJpbmcg cmVmaW5lbWVudCB0byBhdm9pZCBnZW5lcmF0aW5nIHNtYWxsIGFuZ2xlcy4gIEkNCj4gdGhp bmsgdGhpcyB3YXMgdGVzdGVkIHByZXR0eSBleHRlbnNpdmVseSwgYnV0IEkgY291bGQgYmUg d3JvbmcuDQoNCldlIGFyZSBhd2FyZSBvZiB0aGlzLiBXZSB0cmllZCByZXZlcnRpbmcgdG8g dGhlIG9sZCAidW5zd2FwcGVkIiAgDQpyZWZpbmVtZW50LA0KYW5kIHRoaW5ncyBhcHBhcmVu dGx5IGdvdCB3b3JzZS4gSXQgZG9lc24ndCBsb29rIGxpa2UgYSBidWcgaW4gdGhlICANCnN3 YXBwaW5nDQppbXBsZW1lbnRhdGlvbi4NCg0KVG9tb3Jyb3cgd2UnbGwgcG9zdCBhIGZldyBp bWFnZXMgb24gb3VyIHdlYnBhZ2UgZm9yIHlvdSB0byBjaGVjayBvdXQuDQoNClRoYW5rcyBm b3IgdGhlIGhlbHAgeW91J3JlIHByb3ZpZGluZw0KDQpMdWNhDQoNCi0tDQpMdWNhIEFudGln YSwgUGhEDQpIZWFkLCBNZWRpY2FsIEltYWdpbmcgVW5pdCwNCkJpb2VuZ2luZWVyaW5nIERl cGFydG1lbnQsDQpNYXJpbyBOZWdyaSBJbnN0aXR1dGUNCmVtYWlsOiBhbnRpZ2FAbWFyaW9u ZWdyaS5pdA0Kd2ViOiBodHRwOi8vdmlsbGFjYW1venppLm1hcmlvbmVncmkuaXQvfmx1Y2EN Cm1haWw6IFZpbGxhIENhbW96emksIDI0MDIwLCBSYW5pY2EgKEJHKSwgSXRhbHkNCnBob25l OiArMzkgMDM1IDQ1MzUtMzgxDQoNCg0KT24gQXByIDMsIDIwMDcsIGF0IDY6MTMgUE0sIFJv eSBTdG9nbmVyIHdyb3RlOg0KDQo+IE9uIFR1ZSwgMyBBcHIgMjAwNywgTG9yZW56byBCb3R0 aSB3cm90ZToNCj4NCj4+IEFmdGVyIHlvdXIgc3VnZ2VzdGlvbnMgd2UndmUgdGVzdGVkIG91 ciBuYXZpZXJzdG9rZXMgc29sdmVyIG9uIHRoZSAzRA0KPj4gbGlkIGRyaXZlbiBjYXZpdHkg cHJvYmxlbSB3aXRoIGJvdGggaGV4MjcgYW5kIHRldDEwLg0KPj4gQW1yIHdvcmtzIGdyZWF0 IHdpdGggaGV4IGFuZCB0aGUgcHJvYmxlbSB3ZSBlbmNvdW50ZXJlZCB3aXRoIHRldDEwIGlz DQo+PiBsaW1pdGVkIHRvIHRoZSBzZWxlY3Rpb24gb2YgbWVzaCByZWZpbmVtZXQgbGV2ZWxz IGdyZWF0ZXIgdGhhbiBvbmUuDQo+DQo+IFdoYXQgZG8geW91IG1lYW4gYnkgIm1lc2ggcmVm aW5lbWVudCBsZXZlbHMgZ3JlYXRlciB0aGFuIG9uZSI/DQo+IFJlbGF4aW5nIHRoZSBkZWZh dWx0IGxldmVsLW9uZSBoYW5naW5nIG5vZGUgcmVzdHJpY3Rpb24/ICBNb3JlIHRoYW4NCj4g b25lIGxldmVsIG9mIGluaXRpYWwgdW5pZm9ybSByZWZpbmVtZW50PyAgTW9yZSB0aGFuIG9u ZSBsZXZlbCBvZiBBTVINCj4gb24gdG9wIG9mIGEgdW5pZm9ybSBncmlkPw0KPg0KPj4gQ291 bGQgdGhpcyBzdWdnZXN0IGEgcG9zc2libGUgcHJvYmxlbSBpbiBsaWJtZXNoPyBXZSdyZQ0K Pj4gaW52ZXN0aWdhdGluZyB0aGlzLi4uDQo+DQo+IEkndmUgbmV2ZXIgZG9uZSBOYXZpZXIt U3Rva2VzIHdpdGggdGV0czsgaXMgaXQgcG9zc2libGUgdGhhdCB0ZXQgQU1SDQo+ICh3aXRo IHF1YWRyYXRpYyB2ZWxvY2l0eSwgbGluZWFyIHByZXNzdXJlLCBJIGFzc3VtZSkgbGVhZHMg dG8gTEJCDQo+IHZpb2xhdGlvbnM/ICBZb3UgbWlnaHQgc2VlIGlmIHlvdSBjYW4gcmVwcm9k dWNlIHRoZSBwcm9ibGVtIG9uIGEgUERFDQo+IHdpdGggYSBwb3NpdGl2ZSBkZWZpbml0ZSB3 ZWFrIGZvcm0uDQo+DQo+IElmIGl0IGlzIGEgbGliTWVzaCBidWcsIG15IGZpcnN0IGluc3Rp bmN0IHdvdWxkIGJlIHRvIGRvdWJsZWNoZWNrIHRoYXQNCj4gdGhlIGhhbmdpbmcgbm9kZSBj b25zdHJhaW50cyBhcmUgYmVpbmcgcHJvcGVybHkgY3JlYXRlZCBhbmQgc2F0aXNmaWVkLg0K PiBUcnkgdGhlICJEaXNjb250aW51aXR5TWVhc3VyZSIgb2JqZWN0IHRvIG1ha2Ugc3VyZSB0 aGF0IHlvdXINCj4gaW50ZXJlbGVtZW50IGp1bXBzIG9uIHRoZSBmYWlsaW5nIG1lc2hlcyBh cmUgb24gdGhlIG9yZGVyIG9mIG1hY2hpbmUNCj4gcHJlY2lzaW9uLg0KPiAtLS0NCj4gUm95 DQo+DQo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gDQo+IC0tLQ0KPiBUYWtlIFN1cnZleXMuIEVhcm4g Q2FzaC4gSW5mbHVlbmNlIHRoZSBGdXR1cmUgb2YgSVQNCj4gSm9pbiBTb3VyY2VGb3JnZS5u ZXQncyBUZWNoc2F5IHBhbmVsIGFuZCB5b3UnbGwgZ2V0IHRoZSBjaGFuY2UgdG8gIA0KPiBz aGFyZSB5b3VyDQo+IG9waW5pb25zIG9uIElUICYgYnVzaW5lc3MgdG9waWNzIHRocm91Z2gg YnJpZWYgc3VydmV5cy1hbmQgZWFybiBjYXNoDQo+IGh0dHA6Ly93d3cudGVjaHNheS5jb20v ZGVmYXVsdC5waHA/IA0KPiBwYWdlPWpvaW4ucGhwJnA9c291cmNlZm9yZ2UmQ0lEPURFVkRF Vg0KPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXw0K PiBMaWJtZXNoLXVzZXJzIG1haWxpbmcgbGlzdA0KPiBMaWJtZXNoLXVzZXJzQGxpc3RzLnNv dXJjZWZvcmdlLm5ldA0KPiBodHRwczovL2xpc3RzLnNvdXJjZWZvcmdlLm5ldC9saXN0cy9s aXN0aW5mby9saWJtZXNoLXVzZXJzDQoNCg0KDQoNCi0tLQ0KRGVzdGluYSBpbCB0dW8gNSBw ZXIgbWlsbGUgZGVsbCdJUlBFRiAgKHN1bCBtb2QuIDczMCBvIG1vZC4gVU5JQ08gbw0KbW9k LiBDVUQpIGZpcm1hbmRvIGUgaW5kaWNhbmRvIGlsIG5vc3RybyBjb2RpY2UgZmlzY2FsZSAw MzI1NDIxMDE1MA0KbmVsIHJpcXVhZHJvICAgImZpbmFuemlhbWVudG8gYWdsaSBlbnRpIGRl bGxhIHJpY2VyY2Egc2NpZW50aWZpY2EgZQ0KZGVsbCd1bml2ZXJzaXRhJyIgICBwZXIgYWl1 dGFyZSBhIG1hbnRlbmVyZSBpbmRpcGVuZGVudGUgbGEgcmljZXJjYQ0Kc2NpZW50aWZpY2Eg ZGVsbCdJc3RpdHV0byBNYXJpbyBOZWdyaSwgdW5hIGZvbmRhemlvbmUgcHJpdmF0YSBzZW56 YQ0Kc2NvcG8gZGkgbHVjcm8gY2hlIGRhIG9sdHJlIDQwIGFubmkgb3BlcmEgbmVsbCdpbnRl cmVzc2UgZGVnbGkNCmFtbWFsYXRpLg0KDQpQZXIgbWFnZ2lvcmkgaW5mb3JtYXppb25pOg0K SXN0aXR1dG8gTWFyaW8gTmVncmksIFZpYSBFcml0cmVhIDYyIC0gMjAxNTcgTWlsYW5vDQpU ZWw6ICszOSAwMiAzOTAxNDMxNyAtIEZheDogKzM5IDAyIDM1NDYyNzcgKzM5IDAyIDM5MDAx OTE4DQpJbnRlcm5ldDogd3d3Lm1hcmlvbmVncmkuaXQsIG1uZWdyaUBtYXJpb25lZ3JpLml0 ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-04 13:27 Attachments: u.png      vectors.png      Message as HTML ```Hi, I looked again at the image you sent us. I'm not sure there's anything wrong ... it looks like you have "Use Log" enabled in GMV, which is making some interior velocity vectors look like they are coming outside the domain. I attach a few AMR pictures from ex18 of the x-velocity contours and the velocity vectors with "Use Log" disabled. The L2 imposition of the boundary conditions sets u=0.5 along the top "edge". There are some regions of localized overshoots on the lid, seen in pink. -John ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-04 13:34 ```Just in case those pngs didn't make it through.... http://www.cfdlab.ae.utexas.edu/~peterson/vectors.png http://www.cfdlab.ae.utexas.edu/~peterson/u.png > John Peterson writes: > > Hi, > > > > I looked again at the image you sent us. I'm not sure there's > > anything wrong ... it looks like you have "Use Log" enabled in > > GMV, which is making some interior velocity vectors look like they > > are coming outside the domain. I attach a few AMR pictures from > > ex18 of the x-velocity contours and the velocity vectors with > > "Use Log" disabled. The L2 imposition of the boundary conditions > > sets u=0.5 along the top "edge". There are some regions of localized > > overshoots on the lid, seen in pink. > > > > -John > > > > Luca Antiga writes: > > Roy, John, > > thanks for the prompt follow ups. > > I reply on Lorenzo's behalf since we're working together and he's > > out of the office today. > > > > > What do you mean by "mesh refinement levels greater than one"? > > > Relaxing the default level-one hanging node restriction? More than > > > one level of initial uniform refinement? More than one level of AMR > > > on top of a uniform grid? > > > > More than one level of AMR on top of a uniform grid, that was our test. > > > > > I've never done Navier-Stokes with tets; is it possible that tet AMR > > > (with quadratic velocity, linear pressure, I assume) leads to LBB > > > violations? You might see if you can reproduce the problem on a PDE > > > with a positive definite weak form. > > > > Yes, P2P1 10-noded tets, LBB stable (without AMR). > > This is a good point, however we're seeing no spurious pressure modes > > in the refined meshes. Plus, it seems to work with the first level of > > refinement. > > We'll test it with a positive definite weak form, that's a good idea. > > > > Another test we want to perform is imposing Dirichlet boundary > > conditions > > the old Lagrangian way, by setting the diagonal term to 1, the extra- > > diagonal > > terms to 0 and the rhs to the bc value. > > > > The fact is that no matter what we try, it seems we're not able to > > impose boundary > > conditions exactly. We always see spurious velocities on side wall > > elements in all > > children whose parents are adjacent to the top wall. > > > > > If it is a libMesh bug, my first instinct would be to doublecheck that > > > the hanging node constraints are being properly created and satisfied. > > > Try the "DiscontinuityMeasure" object to make sure that your > > > interelement jumps on the failing meshes are on the order of machine > > > precision. > > > > Another good suggestion. We still don't know the details of the AMR > > implementation > > used in libmesh. We're learning as we go. > > > > > There could be a problem with the tets+adaptivity. Tim Kroger > > > recently > > > introduced a new refinement pattern for tetrahedral elements which > > > performs > > > an "edge swap" during refinement to avoid generating small angles. I > > > think this was tested pretty extensively, but I could be wrong. > > > > We are aware of this. We tried reverting to the old "unswapped" > > refinement, > > and things apparently got worse. It doesn't look like a bug in the > > swapping > > implementation. > > > > Tomorrow we'll post a few images on our webpage for you to check out. > > > > Thanks for the help you're providing > > > > Luca > > > > -- > > Luca Antiga, PhD > > Head, Medical Imaging Unit, > > Bioengineering Department, > > Mario Negri Institute > > email: antiga@... > > web: http://villacamozzi.marionegri.it/~luca > > mail: Villa Camozzi, 24020, Ranica (BG), Italy > > phone: +39 035 4535-381 > > > > > > On Apr 3, 2007, at 6:13 PM, Roy Stogner wrote: > > > > > On Tue, 3 Apr 2007, Lorenzo Botti wrote: > > > > > >> After your suggestions we've tested our navierstokes solver on the 3D > > >> lid driven cavity problem with both hex27 and tet10. > > >> Amr works great with hex and the problem we encountered with tet10 is > > >> limited to the selection of mesh refinemet levels greater than one. > > > > > > What do you mean by "mesh refinement levels greater than one"? > > > Relaxing the default level-one hanging node restriction? More than > > > one level of initial uniform refinement? More than one level of AMR > > > on top of a uniform grid? > > > > > >> Could this suggest a possible problem in libmesh? We're > > >> investigating this... > > > > > > I've never done Navier-Stokes with tets; is it possible that tet AMR > > > (with quadratic velocity, linear pressure, I assume) leads to LBB > > > violations? You might see if you can reproduce the problem on a PDE > > > with a positive definite weak form. > > > > > > If it is a libMesh bug, my first instinct would be to doublecheck that > > > the hanging node constraints are being properly created and satisfied. > > > Try the "DiscontinuityMeasure" object to make sure that your > > > interelement jumps on the failing meshes are on the order of machine > > > precision. > > > --- > > > Roy > > > > > > ---------------------------------------------------------------------- > > > --- > > > Take Surveys. Earn Cash. Influence the Future of IT > > > Join SourceForge.net's Techsay panel and you'll get the chance to > > > share your > > > opinions on IT & business topics through brief surveys-and earn cash > > > http://www.techsay.com/default.php? > > > page=join.php&p=sourceforge&CID=DEVDEV > > > _______________________________________________ > > > Libmesh-users mailing list > > > Libmesh-users@... > > > https://lists.sourceforge.net/lists/listinfo/libmesh-users > > ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-04 14:00 ```SGkgSm9obiwNCiAgdGhhbmtzIGZvciB0aGUgaW1hZ2VzLg0KSW4gZmFjdCB3ZSB3ZXJlIGEg Yml0IHdvcnJpZWQgYWJvdXQgdGhlIG92ZXJzaG9vdHMgYXMgd2VsbCBhcyB0aGUgIA0KdW5k ZXJzaG9vdHMuDQpMZXQncyBjb25zaWRlciB0aGUgWT0wIGZhY2UgKHRoZSBzaWRlIGZhY2lu ZyB1cyBpbiB0aGUgaW1hZ2VzKS4NCkluIHRoZSB1IGltYWdlLCBvbiB0aGUgWD0wLjUgbGlu ZSwgZm9yIFogPiAwLjUsIHlvdSBmaXJzdCBzZWUgYW4gIA0KdW5kZXJzaG9vdA0KY29ycmVz cG9uZGluZyB0byB0aGUgZmlyc3QgcmVmaW5lZCBub2RlIChhdCBaPTAuNjI1KSwgdGhlbiB5 b3Ugc2VlIGFuICANCm92ZXJzaG9vdA0KYWxvbmcgdGhlIHJlZmluZWQgbm9kZXMgYWJvdmUg Wj0wLjc1LiAoSSB1c2UgdGhlIHRlcm0gInJlZmluZWQgbm9kZSIgIA0KdG8gaW5kaWNhdGUN Cm5vZGVzIHRoYXQgaGF2ZSBiZWVuIGFkZGVkIGR1cmluZyBBTVIpLg0KSXQgbG9va3MgbGlr ZSB0aGUgc3RlbmNpbCBvZiB0aGUgcG9pbnQgIGF0IFg9MC41IFo9MSBleHRlbmRzIGRvd24g dGhlICANCnZlcnRpY2FsIGxpbmUgWD0wLjUNCmluY2x1ZGluZyBhbGwgcmVmaW5lZCBub2Rl cyB1bnRpbCB0aGUgZmlyc3Qgbm9kZSBvZiB0aGUgb3JpZ2luYWwgbWVzaCAgDQooWj0wLjc1 KS4NCklzIHRoZXJlIGFueSB3YXkgaW4gd2hpY2ggdGhlIGhhbmdpbmcgbm9kZSBjb25zdHJh aW50cyBhcmUgY3JlYXRpbmcgIA0KcHJvYmxlbXM/DQpPciBpcyB0aGlzIGFuIGV4cGVjdGVk IGJlaGF2aW9yPw0KDQooQSBzaW1pbGFyIHRoaW5nIGNvdWxkIGJlIHNhaWQgYWJvdXQgdGhl IGhvcml6b250YWwgcm93IG9mIHJlZmluZWQgIA0Kbm9kZXMgYXQgMC45Mzc1LA0KaW4gd2hp Y2ggeW91IGNhbiBzZWUgYW4gb3ZlcnNob290IGFsbCBhbG9uZyB0aGUgZmFjZS4pDQoNCkkg Y291bGQgbGl2ZSB3aXRoIG5vbiB6ZXJvIHZhbHVlcyBvbiB0aGUgemVybyB2ZWxvY2l0eSBm YWNlcywgYnV0ICANCmFyZW4ndCB0aG9zZSBhIGJpdCBsYXJnZQ0KKDEwJSBvZiB0aGUgdG9w IGZhY2UgdmVsb2NpdHkpPw0KSSdtIGp1c3Qgd29ycmllZCB0aGF0IHRoZSBzaXR1YXRpb24g bWlnaHQgZ28gb3V0IG9mIGNvbnRyb2wgaW4gIA0KY29tcGxpY2F0ZWQgZ2VvbWV0cmllcywg c28NCnRoYXQncyB3aHkgSSdtIGEgYml0IHBpY2t5IG9uIHRoaXMgcHJvYmxlbS4NClNvcnJ5 IGZvciB0aGUgaGFzc2xlIQ0KDQpMdWNhDQoNCg0KLS0NCkx1Y2EgQW50aWdhLCBQaEQNCkhl YWQsIE1lZGljYWwgSW1hZ2luZyBVbml0LA0KQmlvZW5naW5lZXJpbmcgRGVwYXJ0bWVudCwN Ck1hcmlvIE5lZ3JpIEluc3RpdHV0ZQ0KZW1haWw6IGFudGlnYUBtYXJpb25lZ3JpLml0DQp3 ZWI6IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVjYQ0KbWFpbDogVmls bGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmljYSAoQkcpLCBJdGFseQ0KcGhvbmU6ICszOSAwMzUg NDUzNS0zODENCg0KDQpPbiBBcHIgNCwgMjAwNywgYXQgMzoyNiBQTSwgSm9obiBQZXRlcnNv biB3cm90ZToNCg0KPiBIaSwNCj4NCj4gSSBsb29rZWQgYWdhaW4gYXQgdGhlIGltYWdlIHlv dSBzZW50IHVzLiAgSSdtIG5vdCBzdXJlIHRoZXJlJ3MNCj4gYW55dGhpbmcgd3JvbmcgLi4u IGl0IGxvb2tzIGxpa2UgeW91IGhhdmUgIlVzZSBMb2ciIGVuYWJsZWQgaW4NCj4gR01WLCB3 aGljaCBpcyBtYWtpbmcgc29tZSBpbnRlcmlvciB2ZWxvY2l0eSB2ZWN0b3JzIGxvb2sgbGlr ZSB0aGV5DQo+IGFyZSBjb21pbmcgb3V0c2lkZSB0aGUgZG9tYWluLiAgSSBhdHRhY2ggYSBm ZXcgQU1SIHBpY3R1cmVzIGZyb20NCj4gZXgxOCBvZiB0aGUgeC12ZWxvY2l0eSBjb250b3Vy cyBhbmQgdGhlIHZlbG9jaXR5IHZlY3RvcnMgd2l0aA0KPiAiVXNlIExvZyIgZGlzYWJsZWQu ICBUaGUgTDIgaW1wb3NpdGlvbiBvZiB0aGUgYm91bmRhcnkgY29uZGl0aW9ucw0KPiBzZXRz IHU9MC41IGFsb25nIHRoZSB0b3AgImVkZ2UiLiAgVGhlcmUgYXJlIHNvbWUgcmVnaW9ucyBv ZiBsb2NhbGl6ZWQNCj4gb3ZlcnNob290cyBvbiB0aGUgbGlkLCBzZWVuIGluIHBpbmsuDQo+ DQo+IC1Kb2huDQo+DQo+IDx1LnBuZz4NCj4gPHZlY3RvcnMucG5nPg0KPg0KPg0KPiBMdWNh IEFudGlnYSB3cml0ZXM6DQo+PiBSb3ksIEpvaG4sDQo+PiAgIHRoYW5rcyBmb3IgdGhlIHBy b21wdCBmb2xsb3cgdXBzLg0KPj4gICBJIHJlcGx5IG9uIExvcmVuem8ncyBiZWhhbGYgc2lu Y2Ugd2UncmUgd29ya2luZyB0b2dldGhlciBhbmQgaGUncw0KPj4gb3V0IG9mIHRoZSBvZmZp Y2UgdG9kYXkuDQo+Pg0KPj4+IFdoYXQgZG8geW91IG1lYW4gYnkgIm1lc2ggcmVmaW5lbWVu dCBsZXZlbHMgZ3JlYXRlciB0aGFuIG9uZSI/DQo+Pj4gUmVsYXhpbmcgdGhlIGRlZmF1bHQg bGV2ZWwtb25lIGhhbmdpbmcgbm9kZSByZXN0cmljdGlvbj8gIE1vcmUgdGhhbg0KPj4+IG9u ZSBsZXZlbCBvZiBpbml0aWFsIHVuaWZvcm0gcmVmaW5lbWVudD8gIE1vcmUgdGhhbiBvbmUg bGV2ZWwgb2YgQU1SDQo+Pj4gb24gdG9wIG9mIGEgdW5pZm9ybSBncmlkPw0KPj4NCj4+IE1v cmUgdGhhbiBvbmUgbGV2ZWwgb2YgQU1SIG9uIHRvcCBvZiBhIHVuaWZvcm0gZ3JpZCwgdGhh dCB3YXMgb3VyICANCj4+IHRlc3QuDQo+Pg0KPj4+IEkndmUgbmV2ZXIgZG9uZSBOYXZpZXIt U3Rva2VzIHdpdGggdGV0czsgaXMgaXQgcG9zc2libGUgdGhhdCB0ZXQgQU1SDQo+Pj4gKHdp dGggcXVhZHJhdGljIHZlbG9jaXR5LCBsaW5lYXIgcHJlc3N1cmUsIEkgYXNzdW1lKSBsZWFk cyB0byBMQkINCj4+PiB2aW9sYXRpb25zPyAgWW91IG1pZ2h0IHNlZSBpZiB5b3UgY2FuIHJl cHJvZHVjZSB0aGUgcHJvYmxlbSBvbiBhIFBERQ0KPj4+IHdpdGggYSBwb3NpdGl2ZSBkZWZp bml0ZSB3ZWFrIGZvcm0uDQo+Pg0KPj4gWWVzLCBQMlAxIDEwLW5vZGVkIHRldHMsIExCQiBz dGFibGUgKHdpdGhvdXQgQU1SKS4NCj4+IFRoaXMgaXMgYSBnb29kIHBvaW50LCBob3dldmVy IHdlJ3JlIHNlZWluZyBubyBzcHVyaW91cyBwcmVzc3VyZSBtb2Rlcw0KPj4gaW4gdGhlIHJl ZmluZWQgbWVzaGVzLiBQbHVzLCBpdCBzZWVtcyB0byB3b3JrIHdpdGggdGhlIGZpcnN0IGxl dmVsIG9mDQo+PiByZWZpbmVtZW50Lg0KPj4gV2UnbGwgdGVzdCBpdCB3aXRoIGEgcG9zaXRp dmUgZGVmaW5pdGUgd2VhayBmb3JtLCB0aGF0J3MgYSBnb29kIGlkZWEuDQo+Pg0KPj4gQW5v dGhlciB0ZXN0IHdlIHdhbnQgdG8gcGVyZm9ybSBpcyBpbXBvc2luZyBEaXJpY2hsZXQgYm91 bmRhcnkNCj4+IGNvbmRpdGlvbnMNCj4+IHRoZSBvbGQgTGFncmFuZ2lhbiB3YXksIGJ5IHNl dHRpbmcgdGhlIGRpYWdvbmFsIHRlcm0gdG8gMSwgdGhlIGV4dHJhLQ0KPj4gZGlhZ29uYWwN Cj4+IHRlcm1zIHRvIDAgYW5kIHRoZSByaHMgdG8gdGhlIGJjIHZhbHVlLg0KPj4NCj4+IFRo ZSBmYWN0IGlzIHRoYXQgbm8gbWF0dGVyIHdoYXQgd2UgdHJ5LCBpdCBzZWVtcyB3ZSdyZSBu b3QgYWJsZSB0bw0KPj4gaW1wb3NlIGJvdW5kYXJ5DQo+PiBjb25kaXRpb25zIGV4YWN0bHku IFdlIGFsd2F5cyBzZWUgc3B1cmlvdXMgdmVsb2NpdGllcyBvbiBzaWRlIHdhbGwNCj4+IGVs ZW1lbnRzIGluIGFsbA0KPj4gY2hpbGRyZW4gd2hvc2UgcGFyZW50cyBhcmUgYWRqYWNlbnQg dG8gdGhlIHRvcCB3YWxsLg0KPj4NCj4+PiBJZiBpdCBpcyBhIGxpYk1lc2ggYnVnLCBteSBm aXJzdCBpbnN0aW5jdCB3b3VsZCBiZSB0byBkb3VibGVjaGVjayAgDQo+Pj4gdGhhdA0KPj4+ IHRoZSBoYW5naW5nIG5vZGUgY29uc3RyYWludHMgYXJlIGJlaW5nIHByb3Blcmx5IGNyZWF0 ZWQgYW5kICANCj4+PiBzYXRpc2ZpZWQuDQo+Pj4gVHJ5IHRoZSAiRGlzY29udGludWl0eU1l YXN1cmUiIG9iamVjdCB0byBtYWtlIHN1cmUgdGhhdCB5b3VyDQo+Pj4gaW50ZXJlbGVtZW50 IGp1bXBzIG9uIHRoZSBmYWlsaW5nIG1lc2hlcyBhcmUgb24gdGhlIG9yZGVyIG9mIG1hY2hp bmUNCj4+PiBwcmVjaXNpb24uDQo+Pg0KPj4gQW5vdGhlciBnb29kIHN1Z2dlc3Rpb24uIFdl IHN0aWxsIGRvbid0IGtub3cgdGhlIGRldGFpbHMgb2YgdGhlIEFNUg0KPj4gaW1wbGVtZW50 YXRpb24NCj4+IHVzZWQgaW4gbGlibWVzaC4gV2UncmUgbGVhcm5pbmcgYXMgd2UgZ28uDQo+ Pg0KPj4+IFRoZXJlIGNvdWxkIGJlIGEgcHJvYmxlbSB3aXRoIHRoZSB0ZXRzK2FkYXB0aXZp dHkuICBUaW0gS3JvZ2VyDQo+Pj4gcmVjZW50bHkNCj4+PiBpbnRyb2R1Y2VkIGEgbmV3IHJl ZmluZW1lbnQgcGF0dGVybiBmb3IgdGV0cmFoZWRyYWwgZWxlbWVudHMgd2hpY2gNCj4+PiBw ZXJmb3Jtcw0KPj4+IGFuICJlZGdlIHN3YXAiIGR1cmluZyByZWZpbmVtZW50IHRvIGF2b2lk IGdlbmVyYXRpbmcgc21hbGwgIA0KPj4+IGFuZ2xlcy4gIEkNCj4+PiB0aGluayB0aGlzIHdh cyB0ZXN0ZWQgcHJldHR5IGV4dGVuc2l2ZWx5LCBidXQgSSBjb3VsZCBiZSB3cm9uZy4NCj4+ DQo+PiBXZSBhcmUgYXdhcmUgb2YgdGhpcy4gV2UgdHJpZWQgcmV2ZXJ0aW5nIHRvIHRoZSBv bGQgInVuc3dhcHBlZCINCj4+IHJlZmluZW1lbnQsDQo+PiBhbmQgdGhpbmdzIGFwcGFyZW50 bHkgZ290IHdvcnNlLiBJdCBkb2Vzbid0IGxvb2sgbGlrZSBhIGJ1ZyBpbiB0aGUNCj4+IHN3 YXBwaW5nDQo+PiBpbXBsZW1lbnRhdGlvbi4NCj4+DQo+PiBUb21vcnJvdyB3ZSdsbCBwb3N0 IGEgZmV3IGltYWdlcyBvbiBvdXIgd2VicGFnZSBmb3IgeW91IHRvIGNoZWNrIG91dC4NCj4+ DQo+PiBUaGFua3MgZm9yIHRoZSBoZWxwIHlvdSdyZSBwcm92aWRpbmcNCj4+DQo+PiBMdWNh DQo+Pg0KPj4gLS0NCj4+IEx1Y2EgQW50aWdhLCBQaEQNCj4+IEhlYWQsIE1lZGljYWwgSW1h Z2luZyBVbml0LA0KPj4gQmlvZW5naW5lZXJpbmcgRGVwYXJ0bWVudCwNCj4+IE1hcmlvIE5l Z3JpIEluc3RpdHV0ZQ0KPj4gZW1haWw6IGFudGlnYUBtYXJpb25lZ3JpLml0DQo+PiB3ZWI6 IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVjYQ0KPj4gbWFpbDogVmls bGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmljYSAoQkcpLCBJdGFseQ0KPj4gcGhvbmU6ICszOSAw MzUgNDUzNS0zODENCj4+DQo+Pg0KPj4gT24gQXByIDMsIDIwMDcsIGF0IDY6MTMgUE0sIFJv eSBTdG9nbmVyIHdyb3RlOg0KPj4NCj4+PiBPbiBUdWUsIDMgQXByIDIwMDcsIExvcmVuem8g Qm90dGkgd3JvdGU6DQo+Pj4NCj4+Pj4gQWZ0ZXIgeW91ciBzdWdnZXN0aW9ucyB3ZSd2ZSB0 ZXN0ZWQgb3VyIG5hdmllcnN0b2tlcyBzb2x2ZXIgb24gIA0KPj4+PiB0aGUgM0QNCj4+Pj4g bGlkIGRyaXZlbiBjYXZpdHkgcHJvYmxlbSB3aXRoIGJvdGggaGV4MjcgYW5kIHRldDEwLg0K Pj4+PiBBbXIgd29ya3MgZ3JlYXQgd2l0aCBoZXggYW5kIHRoZSBwcm9ibGVtIHdlIGVuY291 bnRlcmVkIHdpdGggIA0KPj4+PiB0ZXQxMCBpcw0KPj4+PiBsaW1pdGVkIHRvIHRoZSBzZWxl Y3Rpb24gb2YgbWVzaCByZWZpbmVtZXQgbGV2ZWxzIGdyZWF0ZXIgdGhhbiBvbmUuDQo+Pj4N Cj4+PiBXaGF0IGRvIHlvdSBtZWFuIGJ5ICJtZXNoIHJlZmluZW1lbnQgbGV2ZWxzIGdyZWF0 ZXIgdGhhbiBvbmUiPw0KPj4+IFJlbGF4aW5nIHRoZSBkZWZhdWx0IGxldmVsLW9uZSBoYW5n aW5nIG5vZGUgcmVzdHJpY3Rpb24/ICBNb3JlIHRoYW4NCj4+PiBvbmUgbGV2ZWwgb2YgaW5p dGlhbCB1bmlmb3JtIHJlZmluZW1lbnQ/ICBNb3JlIHRoYW4gb25lIGxldmVsIG9mIEFNUg0K Pj4+IG9uIHRvcCBvZiBhIHVuaWZvcm0gZ3JpZD8NCj4+Pg0KPj4+PiBDb3VsZCB0aGlzIHN1 Z2dlc3QgYSBwb3NzaWJsZSBwcm9ibGVtIGluIGxpYm1lc2g/IFdlJ3JlDQo+Pj4+IGludmVz dGlnYXRpbmcgdGhpcy4uLg0KPj4+DQo+Pj4gSSd2ZSBuZXZlciBkb25lIE5hdmllci1TdG9r ZXMgd2l0aCB0ZXRzOyBpcyBpdCBwb3NzaWJsZSB0aGF0IHRldCBBTVINCj4+PiAod2l0aCBx dWFkcmF0aWMgdmVsb2NpdHksIGxpbmVhciBwcmVzc3VyZSwgSSBhc3N1bWUpIGxlYWRzIHRv IExCQg0KPj4+IHZpb2xhdGlvbnM/ICBZb3UgbWlnaHQgc2VlIGlmIHlvdSBjYW4gcmVwcm9k dWNlIHRoZSBwcm9ibGVtIG9uIGEgUERFDQo+Pj4gd2l0aCBhIHBvc2l0aXZlIGRlZmluaXRl IHdlYWsgZm9ybS4NCj4+Pg0KPj4+IElmIGl0IGlzIGEgbGliTWVzaCBidWcsIG15IGZpcnN0 IGluc3RpbmN0IHdvdWxkIGJlIHRvIGRvdWJsZWNoZWNrICANCj4+PiB0aGF0DQo+Pj4gdGhl IGhhbmdpbmcgbm9kZSBjb25zdHJhaW50cyBhcmUgYmVpbmcgcHJvcGVybHkgY3JlYXRlZCBh bmQgIA0KPj4+IHNhdGlzZmllZC4NCj4+PiBUcnkgdGhlICJEaXNjb250aW51aXR5TWVhc3Vy ZSIgb2JqZWN0IHRvIG1ha2Ugc3VyZSB0aGF0IHlvdXINCj4+PiBpbnRlcmVsZW1lbnQganVt cHMgb24gdGhlIGZhaWxpbmcgbWVzaGVzIGFyZSBvbiB0aGUgb3JkZXIgb2YgbWFjaGluZQ0K Pj4+IHByZWNpc2lvbi4NCj4+PiAtLS0NCj4+PiBSb3kNCj4+Pg0KPj4+IC0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tIA0KPj4+IC0tDQo+Pj4gLS0tDQo+Pj4gVGFrZSBTdXJ2ZXlzLiBFYXJuIENhc2guIElu Zmx1ZW5jZSB0aGUgRnV0dXJlIG9mIElUDQo+Pj4gSm9pbiBTb3VyY2VGb3JnZS5uZXQncyBU ZWNoc2F5IHBhbmVsIGFuZCB5b3UnbGwgZ2V0IHRoZSBjaGFuY2UgdG8NCj4+PiBzaGFyZSB5 b3VyDQo+Pj4gb3BpbmlvbnMgb24gSVQgJiBidXNpbmVzcyB0b3BpY3MgdGhyb3VnaCBicmll ZiBzdXJ2ZXlzLWFuZCBlYXJuIGNhc2gNCj4+PiBodHRwOi8vd3d3LnRlY2hzYXkuY29tL2Rl ZmF1bHQucGhwPw0KPj4+IHBhZ2U9am9pbi5waHAmcD1zb3VyY2Vmb3JnZSZDSUQ9REVWREVW DQo+Pj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18N Cj4+PiBMaWJtZXNoLXVzZXJzIG1haWxpbmcgbGlzdA0KPj4+IExpYm1lc2gtdXNlcnNAbGlz dHMuc291cmNlZm9yZ2UubmV0DQo+Pj4gaHR0cHM6Ly9saXN0cy5zb3VyY2Vmb3JnZS5uZXQv bGlzdHMvbGlzdGluZm8vbGlibWVzaC11c2Vycw0KPj4NCj4+DQo+Pg0KPj4NCj4+IC0tLQ0K Pj4gRGVzdGluYSBpbCB0dW8gNSBwZXIgbWlsbGUgZGVsbCdJUlBFRiAgKHN1bCBtb2QuIDcz MCBvIG1vZC4gVU5JQ08gbw0KPj4gbW9kLiBDVUQpIGZpcm1hbmRvIGUgaW5kaWNhbmRvIGls IG5vc3RybyBjb2RpY2UgZmlzY2FsZSAwMzI1NDIxMDE1MA0KPj4gbmVsIHJpcXVhZHJvICAg ImZpbmFuemlhbWVudG8gYWdsaSBlbnRpIGRlbGxhIHJpY2VyY2Egc2NpZW50aWZpY2EgZQ0K Pj4gZGVsbCd1bml2ZXJzaXRhJyIgICBwZXIgYWl1dGFyZSBhIG1hbnRlbmVyZSBpbmRpcGVu ZGVudGUgbGEgcmljZXJjYQ0KPj4gc2NpZW50aWZpY2EgZGVsbCdJc3RpdHV0byBNYXJpbyBO ZWdyaSwgdW5hIGZvbmRhemlvbmUgcHJpdmF0YSBzZW56YQ0KPj4gc2NvcG8gZGkgbHVjcm8g Y2hlIGRhIG9sdHJlIDQwIGFubmkgb3BlcmEgbmVsbCdpbnRlcmVzc2UgZGVnbGkNCj4+IGFt bWFsYXRpLg0KPj4NCj4+IFBlciBtYWdnaW9yaSBpbmZvcm1hemlvbmk6DQo+PiBJc3RpdHV0 byBNYXJpbyBOZWdyaSwgVmlhIEVyaXRyZWEgNjIgLSAyMDE1NyBNaWxhbm8NCj4+IFRlbDog KzM5IDAyIDM5MDE0MzE3IC0gRmF4OiArMzkgMDIgMzU0NjI3NyArMzkgMDIgMzkwMDE5MTgN Cj4+IEludGVybmV0OiB3d3cubWFyaW9uZWdyaS5pdCwgbW5lZ3JpQG1hcmlvbmVncmkuaXQN Cj4+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLSANCj4+IC0tLS0NCj4+IFRha2UgU3VydmV5cy4gRWFybiBD YXNoLiBJbmZsdWVuY2UgdGhlIEZ1dHVyZSBvZiBJVA0KPj4gSm9pbiBTb3VyY2VGb3JnZS5u ZXQncyBUZWNoc2F5IHBhbmVsIGFuZCB5b3UnbGwgZ2V0IHRoZSBjaGFuY2UgdG8gIA0KPj4g c2hhcmUgeW91cg0KPj4gb3BpbmlvbnMgb24gSVQgJiBidXNpbmVzcyB0b3BpY3MgdGhyb3Vn aCBicmllZiBzdXJ2ZXlzLWFuZCBlYXJuIGNhc2gNCj4+IGh0dHA6Ly93d3cudGVjaHNheS5j b20vZGVmYXVsdC5waHA/IA0KPj4gcGFnZT1qb2luLnBocCZwPXNvdXJjZWZvcmdlJkNJRD1E RVZERVYNCj4+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fDQo+PiBMaWJtZXNoLXVzZXJzIG1haWxpbmcgbGlzdA0KPj4gTGlibWVzaC11c2Vyc0Bs aXN0cy5zb3VyY2Vmb3JnZS5uZXQNCj4+IGh0dHBzOi8vbGlzdHMuc291cmNlZm9yZ2UubmV0 L2xpc3RzL2xpc3RpbmZvL2xpYm1lc2gtdXNlcnMNCg0KDQoNCg0KLS0tDQpEZXN0aW5hIGls IHR1byA1IHBlciBtaWxsZSBkZWxsJ0lSUEVGICAoc3VsIG1vZC4gNzMwIG8gbW9kLiBVTklD TyBvDQptb2QuIENVRCkgZmlybWFuZG8gZSBpbmRpY2FuZG8gaWwgbm9zdHJvIGNvZGljZSBm aXNjYWxlIDAzMjU0MjEwMTUwDQpuZWwgcmlxdWFkcm8gICAiZmluYW56aWFtZW50byBhZ2xp IGVudGkgZGVsbGEgcmljZXJjYSBzY2llbnRpZmljYSBlDQpkZWxsJ3VuaXZlcnNpdGEnIiAg IHBlciBhaXV0YXJlIGEgbWFudGVuZXJlIGluZGlwZW5kZW50ZSBsYSByaWNlcmNhDQpzY2ll bnRpZmljYSBkZWxsJ0lzdGl0dXRvIE1hcmlvIE5lZ3JpLCB1bmEgZm9uZGF6aW9uZSBwcml2 YXRhIHNlbnphDQpzY29wbyBkaSBsdWNybyBjaGUgZGEgb2x0cmUgNDAgYW5uaSBvcGVyYSBu ZWxsJ2ludGVyZXNzZSBkZWdsaQ0KYW1tYWxhdGkuDQoNClBlciBtYWdnaW9yaSBpbmZvcm1h emlvbmk6DQpJc3RpdHV0byBNYXJpbyBOZWdyaSwgVmlhIEVyaXRyZWEgNjIgLSAyMDE1NyBN aWxhbm8NClRlbDogKzM5IDAyIDM5MDE0MzE3IC0gRmF4OiArMzkgMDIgMzU0NjI3NyArMzkg MDIgMzkwMDE5MTgNCkludGVybmV0OiB3d3cubWFyaW9uZWdyaS5pdCwgbW5lZ3JpQG1hcmlv bmVncmkuaXQ= ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-04-04 14:11 ```On Wed, 4 Apr 2007, Luca Antiga wrote: > I could live with non zero values on the zero velocity faces, but aren't > those a bit large (10% of the top face velocity)? Yes, but then Gibbs' type ringing usually is large. What's worse: as you refine the mesh the boundary condition approximation will converge in the L2 norm, but it can't converge in L_infinity.. > I'm just worried that the situation might go out of control in > complicated geometries, so that's why I'm a bit picky on this > problem. It's not the geometry that's controlling the problem, it's the discontinuity in the boundary conditions. I think John's had somewhat smoother results by using an H1 instead of L2 boundary penalty, but when you try to force a continuous approximation function to take on discontinuous values, there's really no good way for it to react. Many people give up and just regularize the problem boundary conditions. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-04 14:23 ```Roy Stogner writes: > On Wed, 4 Apr 2007, Luca Antiga wrote: > > > I could live with non zero values on the zero velocity faces, but aren't > > those a bit large (10% of the top face velocity)? > > Yes, but then Gibbs' type ringing usually is large. What's worse: as > you refine the mesh the boundary condition approximation will converge > in the L2 norm, but it can't converge in L_infinity.. > > > I'm just worried that the situation might go out of control in > > complicated geometries, so that's why I'm a bit picky on this > > problem. > > It's not the geometry that's controlling the problem, it's the > discontinuity in the boundary conditions. > I think John's had somewhat smoother results by using an H1 instead > of L2 boundary penalty, but when you try to force a continuous > approximation function to take on discontinuous values, there's > really no good way for it to react. Actually, I couldn't get the H1 projection to work (in 2D). I tried penalizing the tangential derivatives, to e.g. enforce du/dx=dv/dx=0 along the lid. One thing that seemed to help a bit (at least in 2D) was to use the "lumped" L2 projection (e.g. ex13). If memory serves, that solution "looked" slightly better (at least in 2D). > Many people give up and just regularize the problem boundary > conditions. Indeed, the hyperbolic tangent-type regularized boundary conditions seem to be fairly standard in the literature for this type of problem. If we just want to be sure Stokes+AMR+Tets is working, let's try a test problem with continuous data? -J ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-04 14:45 ```SGksDQo+IE9uZSB0aGluZyB0aGF0IHNlZW1lZCB0byBoZWxwIGEgYml0IChhdCBsZWFzdCBp biAyRCkgd2FzIHRvIHVzZSB0aGUNCj4gImx1bXBlZCIgTDIgcHJvamVjdGlvbiAoZS5nLiBl eDEzKS4gIElmIG1lbW9yeSBzZXJ2ZXMsIHRoYXQgc29sdXRpb24NCj4gImxvb2tlZCIgc2xp Z2h0bHkgYmV0dGVyIChhdCBsZWFzdCBpbiAyRCkuDQpXZSBjb25maXJtIHRoYXQgdGhpcyBo ZWxwcyBhbHNvIGluIDNELiBXZSdsbCBzaG93IHlvdSBpbWFnZXMgYXMgc29vbiAgDQphcyBM b3JlbnpvIGlzIGFyb3VuZC4NClRoZSBzaXR1YXRpb24gY2hhbmdlcyBzZW5zaWJseSwgeW91 IHNlZSBtdWNoIGZld2VyIG5vbi16ZXJvIHZlY3RvcnMgIA0Kb24gdGhlIG5vLXNsaXAgZmFj ZXMuDQoNClVsdGltYXRlbHkgd2UnbGwgd29yayB3aXRoIGJsb29kIHZlc3NlbHMsIHNvIHdl IHdvbid0IGhhdmUgIA0KZGlzY29udGludW91cyBib3VuZGFyeSBjb25kaXRpb25zLg0KSG93 ZXZlciwgSSBjYW4gdGVsbCB5b3UgdGhhdCB3ZSB0cmllZCBvbiBhIHZlc3NlbCB3aXRoIHBh cmFib2xpYyAgDQppbmxldCBjb25kaXRpb25zICh0aGF0IGdvIHRvIHplcm8NCmF0IHRoZSB3 YWxsLCBzbyBubyBkaXNjb250aW51aXR5KS4gV2l0aCBMMiBib3VuZGFyeSBjb25kaXRpb25z LCB0aGUgIA0KZmlyc3QgcmluZyBvZiByZWZpbmVkIG5vZGVzIG9uIHRoZQ0Kbm8tc2xpcCBz aWRlIHdhbGwgY29ubmVjdGVkIHRvIHRoZSBpbmxldCBmYWNlIGhhZCBub24temVybyB2ZWxv Y2l0eSAgDQp2ZWN0b3JzIHBvaW50aW5nIG9wcG9zaXRlDQp0byB0aGUgaW5sZXQgZmxvdyBk aXJlY3Rpb24uDQoNCj4+IFllcywgYnV0IHRoZW4gR2liYnMnIHR5cGUgcmluZ2luZyB1c3Vh bGx5IGlzIGxhcmdlLiAgV2hhdCdzIHdvcnNlOiBhcw0KPj4geW91IHJlZmluZSB0aGUgbWVz aCB0aGUgYm91bmRhcnkgY29uZGl0aW9uIGFwcHJveGltYXRpb24gd2lsbCAgDQo+PiBjb252 ZXJnZQ0KPj4gaW4gdGhlIEwyIG5vcm0sIGJ1dCBpdCBjYW4ndCBjb252ZXJnZSBpbiBMX2lu ZmluaXR5Li4NCg0KSSBkb24ndCBrbm93IHRoZSBkZXRhaWxzLCBzbyBJJ20gbm90IHN1cmUg aXQgbWFrZXMgc2Vuc2UsIGJ1dCBpdCAgDQpsb29rcyB0byBtZSBsaWtlIHRoZSBwcmVzZW5j ZSBhbmQgc2l6ZSBvZg0Kb3Zlci11bmRlcnNob290cyBkZXBlbmRzIG9uIHRoZSBzaXplIG9m IHRoZSBjb2Fyc2UtbGV2ZWwgbWVzaC4gQ291bGQgIA0KdGhpcyBiZSByZWxhdGVkIHRvIHRo ZSB3YXkNCmhhbmdpbmcgbm9kZSBjb25zdHJhaW50cyBhcmUgaGFuZGxlZCAoTDIpPw0KSnVz dCB0byBnZXQgbW9yZSBpbnNpZ2h0OiB3aWxsIGEgdW5pZm9ybWx5IEFNUiByZWZpbmVkIG1l c2ggYmVoYXZlICANCmRpZmZlcmVudGx5IHRoYW4gYSBub24tcmVmaW5lZA0KbWVzaCB3aXRo IHRoZSBzYW1lIHNpemVkIGVsZW1lbnRzIGFzIHRoZSBmaW5lIEFNUiBvbmVzPyBIb3cgbXVj aCBvZiAgDQphbiBpbmZsdWVuY2Ugd2lsbCB0aGUgY29hcnNlLWxldmVsDQptZXNoIGhhdmU/ DQoNClRoYW5rcyBhIGxvdCBmb3IgeW91ciB0aW1lDQoNCkx1Y2ENCg0KLS0NCkx1Y2EgQW50 aWdhLCBQaEQNCkhlYWQsIE1lZGljYWwgSW1hZ2luZyBVbml0LA0KQmlvZW5naW5lZXJpbmcg RGVwYXJ0bWVudCwNCk1hcmlvIE5lZ3JpIEluc3RpdHV0ZQ0KZW1haWw6IGFudGlnYUBtYXJp b25lZ3JpLml0DQp3ZWI6IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVj YQ0KbWFpbDogVmlsbGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmljYSAoQkcpLCBJdGFseQ0KcGhv bmU6ICszOSAwMzUgNDUzNS0zODENCg0KDQpPbiBBcHIgNCwgMjAwNywgYXQgNDoyMiBQTSwg Sm9obiBQZXRlcnNvbiB3cm90ZToNCg0KPiBSb3kgU3RvZ25lciB3cml0ZXM6DQo+PiBPbiBX ZWQsIDQgQXByIDIwMDcsIEx1Y2EgQW50aWdhIHdyb3RlOg0KPj4NCj4+PiBJIGNvdWxkIGxp dmUgd2l0aCBub24gemVybyB2YWx1ZXMgb24gdGhlIHplcm8gdmVsb2NpdHkgZmFjZXMsIGJ1 dCAgDQo+Pj4gYXJlbid0DQo+Pj4gdGhvc2UgYSBiaXQgbGFyZ2UgKDEwJSBvZiB0aGUgdG9w IGZhY2UgdmVsb2NpdHkpPw0KPj4NCj4+IFllcywgYnV0IHRoZW4gR2liYnMnIHR5cGUgcmlu Z2luZyB1c3VhbGx5IGlzIGxhcmdlLiAgV2hhdCdzIHdvcnNlOiBhcw0KPj4geW91IHJlZmlu ZSB0aGUgbWVzaCB0aGUgYm91bmRhcnkgY29uZGl0aW9uIGFwcHJveGltYXRpb24gd2lsbCAg DQo+PiBjb252ZXJnZQ0KPj4gaW4gdGhlIEwyIG5vcm0sIGJ1dCBpdCBjYW4ndCBjb252ZXJn ZSBpbiBMX2luZmluaXR5Li4NCj4+DQo+Pj4gSSdtIGp1c3Qgd29ycmllZCB0aGF0IHRoZSBz aXR1YXRpb24gbWlnaHQgZ28gb3V0IG9mIGNvbnRyb2wgaW4NCj4+PiBjb21wbGljYXRlZCBn ZW9tZXRyaWVzLCBzbyB0aGF0J3Mgd2h5IEknbSBhIGJpdCBwaWNreSBvbiB0aGlzDQo+Pj4g cHJvYmxlbS4NCj4+DQo+PiBJdCdzIG5vdCB0aGUgZ2VvbWV0cnkgdGhhdCdzIGNvbnRyb2xs aW5nIHRoZSBwcm9ibGVtLCBpdCdzIHRoZQ0KPj4gZGlzY29udGludWl0eSBpbiB0aGUgYm91 bmRhcnkgY29uZGl0aW9ucy4NCj4NCj4+IEkgdGhpbmsgSm9obidzIGhhZCBzb21ld2hhdCBz bW9vdGhlciByZXN1bHRzIGJ5IHVzaW5nIGFuIEgxIGluc3RlYWQNCj4+IG9mIEwyIGJvdW5k YXJ5IHBlbmFsdHksIGJ1dCB3aGVuIHlvdSB0cnkgdG8gZm9yY2UgYSBjb250aW51b3VzDQo+ PiBhcHByb3hpbWF0aW9uIGZ1bmN0aW9uIHRvIHRha2Ugb24gZGlzY29udGludW91cyB2YWx1 ZXMsIHRoZXJlJ3MNCj4+IHJlYWxseSBubyBnb29kIHdheSBmb3IgaXQgdG8gcmVhY3QuDQo+ DQo+IEFjdHVhbGx5LCBJIGNvdWxkbid0IGdldCB0aGUgSDEgcHJvamVjdGlvbiB0byB3b3Jr IChpbiAyRCkuICBJIHRyaWVkDQo+IHBlbmFsaXppbmcgdGhlIHRhbmdlbnRpYWwgZGVyaXZh dGl2ZXMsIHRvIGUuZy4gZW5mb3JjZSBkdS9keD1kdi9keD0wDQo+IGFsb25nIHRoZSBsaWQu DQo+DQo+IE9uZSB0aGluZyB0aGF0IHNlZW1lZCB0byBoZWxwIGEgYml0IChhdCBsZWFzdCBp biAyRCkgd2FzIHRvIHVzZSB0aGUNCj4gImx1bXBlZCIgTDIgcHJvamVjdGlvbiAoZS5nLiBl eDEzKS4gIElmIG1lbW9yeSBzZXJ2ZXMsIHRoYXQgc29sdXRpb24NCj4gImxvb2tlZCIgc2xp Z2h0bHkgYmV0dGVyIChhdCBsZWFzdCBpbiAyRCkuDQo+DQo+PiBNYW55IHBlb3BsZSBnaXZl IHVwIGFuZCBqdXN0IHJlZ3VsYXJpemUgdGhlIHByb2JsZW0gYm91bmRhcnkNCj4+IGNvbmRp dGlvbnMuDQo+DQo+IEluZGVlZCwgdGhlIGh5cGVyYm9saWMgdGFuZ2VudC10eXBlIHJlZ3Vs YXJpemVkIGJvdW5kYXJ5IGNvbmRpdGlvbnMgIA0KPiBzZWVtIHRvIGJlDQo+IGZhaXJseSBz dGFuZGFyZCBpbiB0aGUgbGl0ZXJhdHVyZSBmb3IgdGhpcyB0eXBlIG9mIHByb2JsZW0uICBJ ZiB3ZSAgDQo+IGp1c3QNCj4gd2FudCB0byBiZSBzdXJlIFN0b2tlcytBTVIrVGV0cyBpcyB3 b3JraW5nLCBsZXQncyB0cnkgYSB0ZXN0IHByb2JsZW0NCj4gd2l0aCBjb250aW51b3VzIGRh dGE/DQo+DQo+IC1KDQo+DQo+IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gDQo+IC0tLQ0KPiBUYWtlIFN1 cnZleXMuIEVhcm4gQ2FzaC4gSW5mbHVlbmNlIHRoZSBGdXR1cmUgb2YgSVQNCj4gSm9pbiBT b3VyY2VGb3JnZS5uZXQncyBUZWNoc2F5IHBhbmVsIGFuZCB5b3UnbGwgZ2V0IHRoZSBjaGFu Y2UgdG8gIA0KPiBzaGFyZSB5b3VyDQo+IG9waW5pb25zIG9uIElUICYgYnVzaW5lc3MgdG9w aWNzIHRocm91Z2ggYnJpZWYgc3VydmV5cy1hbmQgZWFybiBjYXNoDQo+IGh0dHA6Ly93d3cu dGVjaHNheS5jb20vZGVmYXVsdC5waHA/IA0KPiBwYWdlPWpvaW4ucGhwJnA9c291cmNlZm9y Z2UmQ0lEPURFVkRFVg0KPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fXw0KPiBMaWJtZXNoLXVzZXJzIG1haWxpbmcgbGlzdA0KPiBMaWJtZXNoLXVz ZXJzQGxpc3RzLnNvdXJjZWZvcmdlLm5ldA0KPiBodHRwczovL2xpc3RzLnNvdXJjZWZvcmdl Lm5ldC9saXN0cy9saXN0aW5mby9saWJtZXNoLXVzZXJzDQoNCg0KDQoNCi0tLQ0KRGVzdGlu YSBpbCB0dW8gNSBwZXIgbWlsbGUgZGVsbCdJUlBFRiAgKHN1bCBtb2QuIDczMCBvIG1vZC4g VU5JQ08gbw0KbW9kLiBDVUQpIGZpcm1hbmRvIGUgaW5kaWNhbmRvIGlsIG5vc3RybyBjb2Rp Y2UgZmlzY2FsZSAwMzI1NDIxMDE1MA0KbmVsIHJpcXVhZHJvICAgImZpbmFuemlhbWVudG8g YWdsaSBlbnRpIGRlbGxhIHJpY2VyY2Egc2NpZW50aWZpY2EgZQ0KZGVsbCd1bml2ZXJzaXRh JyIgICBwZXIgYWl1dGFyZSBhIG1hbnRlbmVyZSBpbmRpcGVuZGVudGUgbGEgcmljZXJjYQ0K c2NpZW50aWZpY2EgZGVsbCdJc3RpdHV0byBNYXJpbyBOZWdyaSwgdW5hIGZvbmRhemlvbmUg cHJpdmF0YSBzZW56YQ0Kc2NvcG8gZGkgbHVjcm8gY2hlIGRhIG9sdHJlIDQwIGFubmkgb3Bl cmEgbmVsbCdpbnRlcmVzc2UgZGVnbGkNCmFtbWFsYXRpLg0KDQpQZXIgbWFnZ2lvcmkgaW5m b3JtYXppb25pOg0KSXN0aXR1dG8gTWFyaW8gTmVncmksIFZpYSBFcml0cmVhIDYyIC0gMjAx NTcgTWlsYW5vDQpUZWw6ICszOSAwMiAzOTAxNDMxNyAtIEZheDogKzM5IDAyIDM1NDYyNzcg KzM5IDAyIDM5MDAxOTE4DQpJbnRlcm5ldDogd3d3Lm1hcmlvbmVncmkuaXQsIG1uZWdyaUBt YXJpb25lZ3JpLml0 ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-04 15:09 ```Luca Antiga writes: > Hi, > > One thing that seemed to help a bit (at least in 2D) was to use the > > "lumped" L2 projection (e.g. ex13). If memory serves, that solution > > "looked" slightly better (at least in 2D). > We confirm that this helps also in 3D. We'll show you images as soon > as Lorenzo is around. > The situation changes sensibly, you see much fewer non-zero vectors > on the no-slip faces. > > Ultimately we'll work with blood vessels, so we won't have > discontinuous boundary conditions. > However, I can tell you that we tried on a vessel with parabolic > inlet conditions (that go to zero > at the wall, so no discontinuity). With L2 boundary conditions, the > first ring of refined nodes on the > no-slip side wall connected to the inlet face had non-zero velocity > vectors pointing opposite > to the inlet flow direction. Hmm... and the lumped L2-projection looks slightly better than that? I will try implementing the "pinwheel" type forcing function for the Stokes problem with homogeneous zero Dirichlet BCs in 2D using adaptivity, and see what that gives us. > >> Yes, but then Gibbs' type ringing usually is large. What's worse: as > >> you refine the mesh the boundary condition approximation will > >> converge > >> in the L2 norm, but it can't converge in L_infinity.. > > I don't know the details, so I'm not sure it makes sense, but it > looks to me like the presence and size of > over-undershoots depends on the size of the coarse-level mesh. Could > this be related to the way > hanging node constraints are handled (L2)? > Just to get more insight: will a uniformly AMR refined mesh behave > differently than a non-refined > mesh with the same sized elements as the fine AMR ones? How much of > an influence will the coarse-level > mesh have? It shouldn't depend on what mesh you start with, unless it was coarse enough to have Galerkin-instability type oscillations. In that case, local cell-Reynolds number violations can cause over/undershoots (for Navier-Stokes obviously, not Stokes flow). In answer to your second question, a "uniformly-refined AMR mesh" should behave identically to a non-refined mesh with the same size elements. I would be interested in seeing a case where it does not, if you have one. -J > Thanks a lot for your time > > Luca > > -- > Luca Antiga, PhD > Head, Medical Imaging Unit, > Bioengineering Department, > Mario Negri Institute > email: antiga@... > web: http://villacamozzi.marionegri.it/~luca > mail: Villa Camozzi, 24020, Ranica (BG), Italy > phone: +39 035 4535-381 > > > On Apr 4, 2007, at 4:22 PM, John Peterson wrote: > > > Roy Stogner writes: > >> On Wed, 4 Apr 2007, Luca Antiga wrote: > >> > >>> I could live with non zero values on the zero velocity faces, but > >>> aren't > >>> those a bit large (10% of the top face velocity)? > >> > >> Yes, but then Gibbs' type ringing usually is large. What's worse: as > >> you refine the mesh the boundary condition approximation will > >> converge > >> in the L2 norm, but it can't converge in L_infinity.. > >> > >>> I'm just worried that the situation might go out of control in > >>> complicated geometries, so that's why I'm a bit picky on this > >>> problem. > >> > >> It's not the geometry that's controlling the problem, it's the > >> discontinuity in the boundary conditions. > > > >> I think John's had somewhat smoother results by using an H1 instead > >> of L2 boundary penalty, but when you try to force a continuous > >> approximation function to take on discontinuous values, there's > >> really no good way for it to react. > > > > Actually, I couldn't get the H1 projection to work (in 2D). I tried > > penalizing the tangential derivatives, to e.g. enforce du/dx=dv/dx=0 > > along the lid. > > > > One thing that seemed to help a bit (at least in 2D) was to use the > > "lumped" L2 projection (e.g. ex13). If memory serves, that solution > > "looked" slightly better (at least in 2D). > > > >> Many people give up and just regularize the problem boundary > >> conditions. > > > > Indeed, the hyperbolic tangent-type regularized boundary conditions > > seem to be > > fairly standard in the literature for this type of problem. If we > > just > > want to be sure Stokes+AMR+Tets is working, let's try a test problem > > with continuous data? > > > > -J ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-11 10:38 ```SGkgZ3V5cywNCiAgYXMgcHJvbWlzZWQgd2UgdG9vayBhIGZldyBpbWFnZXMgb2YgdGhlIDNE IGxpZC1kcml2ZW4gY2F2aXR5ICANCnNob3dpbmcgdGhlIGRpZmZlcmVuY2UgaXQgbWFrZXMN CnRvIGltcG9zZSBMMiB2cyBsdW1wZWQgcGVuYWx0eSBib3VuZGFyeSBjb25kaXRpb25zLg0K WW91IGNhbiB0YWtlIGEgbG9vayBhdCB0aGVtIGhlcmUNCg0KaHR0cDovL3ZpbGxhY2Ftb3p6 aS5tYXJpb25lZ3JpLml0L35sdWNhL0hleExpZDNkTDIucG5nDQpodHRwOi8vdmlsbGFjYW1v enppLm1hcmlvbmVncmkuaXQvfmx1Y2EvSGV4TGlkM2RMdW1wZWQucG5nDQpodHRwOi8vdmls bGFjYW1venppLm1hcmlvbmVncmkuaXQvfmx1Y2EvVGV0TGlkM2RMMi5wbmcNCmh0dHA6Ly92 aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVjYS9UZXRMaWQzZGx1bXBlZC5wbmcNCg0K d2hlcmUgdGhlIG5hbWVzIG9mIHRoZSBpbWFnZXMgZXhwbGFpbiB3aGljaCBjYXNlIGlzIHdo aWNoLg0KQXMgeW91IGNhbiBzZWUsIGltcG9zaW5nIGx1bXBlZCBib3VuZGFyeSBjb25kaXRp b25zIGRvZXMgbWFrZSBhICANCmRpZmZlcmVuY2UuDQpJbiBwYXJ0aWN1bGFyLCBhcGFydCBm cm9tIHRoZSBzcHVyaW91cyBub24temVybyB2ZWxvY2l0aWVzIG9uIHRoZSAgDQpzaWRlIHdh bGxzLCB0aGUgdG9wDQp2ZWxvY2l0eSBpcyAxIGZvciBsdW1wZWQgYmNzLCB3aGlsZSBpdCBv dmVyc2hvb3RzIGJ5IDIwJSBpbiBjYXNlIG9mICANCkwyIGluIGNhc2Ugb2YgVGV0MTANCmVs ZW1lbnRzLiBXZSBnZXQgYSBiaXQgbGVzcyBwcm9ub3VuY2VkIG92ZXJzaG9vdHMgKDE1JSkg d2l0aCBoZXhhcyAgDQphbmQgTDIuDQoNCldlIHRyaWVkIGxvd2VyaW5nIHRoZSBhYnNvbHV0 ZSB0aHJlc2hvbGQgb2YgdGhlIGxpbmVhciBzeXN0ZW0gIA0Kc29sdmVycywgd2l0aCBubyBh cHByZWNpYWJsZQ0KY2hhbmdlcy4NCg0KTHVjYQ0KDQotLQ0KTHVjYSBBbnRpZ2EsIFBoRA0K SGVhZCwgTWVkaWNhbCBJbWFnaW5nIFVuaXQsDQpCaW9lbmdpbmVlcmluZyBEZXBhcnRtZW50 LA0KTWFyaW8gTmVncmkgSW5zdGl0dXRlDQplbWFpbDogYW50aWdhQG1hcmlvbmVncmkuaXQN CndlYjogaHR0cDovL3ZpbGxhY2Ftb3p6aS5tYXJpb25lZ3JpLml0L35sdWNhDQptYWlsOiBW aWxsYSBDYW1venppLCAyNDAyMCwgUmFuaWNhIChCRyksIEl0YWx5DQpwaG9uZTogKzM5IDAz NSA0NTM1LTM4MQ0KDQoNCk9uIEFwciA0LCAyMDA3LCBhdCA1OjA5IFBNLCBKb2huIFBldGVy c29uIHdyb3RlOg0KDQo+IEx1Y2EgQW50aWdhIHdyaXRlczoNCj4+IEhpLA0KPj4+IE9uZSB0 aGluZyB0aGF0IHNlZW1lZCB0byBoZWxwIGEgYml0IChhdCBsZWFzdCBpbiAyRCkgd2FzIHRv IHVzZSB0aGUNCj4+PiAibHVtcGVkIiBMMiBwcm9qZWN0aW9uIChlLmcuIGV4MTMpLiAgSWYg bWVtb3J5IHNlcnZlcywgdGhhdCBzb2x1dGlvbg0KPj4+ICJsb29rZWQiIHNsaWdodGx5IGJl dHRlciAoYXQgbGVhc3QgaW4gMkQpLg0KPj4gV2UgY29uZmlybSB0aGF0IHRoaXMgaGVscHMg YWxzbyBpbiAzRC4gV2UnbGwgc2hvdyB5b3UgaW1hZ2VzIGFzIHNvb24NCj4+IGFzIExvcmVu em8gaXMgYXJvdW5kLg0KPj4gVGhlIHNpdHVhdGlvbiBjaGFuZ2VzIHNlbnNpYmx5LCB5b3Ug c2VlIG11Y2ggZmV3ZXIgbm9uLXplcm8gdmVjdG9ycw0KPj4gb24gdGhlIG5vLXNsaXAgZmFj ZXMuDQo+Pg0KPj4gVWx0aW1hdGVseSB3ZSdsbCB3b3JrIHdpdGggYmxvb2QgdmVzc2Vscywg c28gd2Ugd29uJ3QgaGF2ZQ0KPj4gZGlzY29udGludW91cyBib3VuZGFyeSBjb25kaXRpb25z Lg0KPj4gSG93ZXZlciwgSSBjYW4gdGVsbCB5b3UgdGhhdCB3ZSB0cmllZCBvbiBhIHZlc3Nl bCB3aXRoIHBhcmFib2xpYw0KPj4gaW5sZXQgY29uZGl0aW9ucyAodGhhdCBnbyB0byB6ZXJv DQo+PiBhdCB0aGUgd2FsbCwgc28gbm8gZGlzY29udGludWl0eSkuIFdpdGggTDIgYm91bmRh cnkgY29uZGl0aW9ucywgdGhlDQo+PiBmaXJzdCByaW5nIG9mIHJlZmluZWQgbm9kZXMgb24g dGhlDQo+PiBuby1zbGlwIHNpZGUgd2FsbCBjb25uZWN0ZWQgdG8gdGhlIGlubGV0IGZhY2Ug aGFkIG5vbi16ZXJvIHZlbG9jaXR5DQo+PiB2ZWN0b3JzIHBvaW50aW5nIG9wcG9zaXRlDQo+ PiB0byB0aGUgaW5sZXQgZmxvdyBkaXJlY3Rpb24uDQo+DQo+IEhtbS4uLiBhbmQgdGhlIGx1 bXBlZCBMMi1wcm9qZWN0aW9uIGxvb2tzIHNsaWdodGx5IGJldHRlciB0aGFuIHRoYXQ/DQo+ IEkgd2lsbCB0cnkgaW1wbGVtZW50aW5nIHRoZSAicGlud2hlZWwiIHR5cGUgZm9yY2luZyBm dW5jdGlvbiBmb3IgdGhlDQo+IFN0b2tlcyBwcm9ibGVtIHdpdGggaG9tb2dlbmVvdXMgemVy byBEaXJpY2hsZXQgQkNzIGluIDJEIHVzaW5nICANCj4gYWRhcHRpdml0eSwNCj4gYW5kIHNl ZSB3aGF0IHRoYXQgZ2l2ZXMgdXMuDQo+DQo+Pj4+IFllcywgYnV0IHRoZW4gR2liYnMnIHR5 cGUgcmluZ2luZyB1c3VhbGx5IGlzIGxhcmdlLiAgV2hhdCdzICANCj4+Pj4gd29yc2U6IGFz DQo+Pj4+IHlvdSByZWZpbmUgdGhlIG1lc2ggdGhlIGJvdW5kYXJ5IGNvbmRpdGlvbiBhcHBy b3hpbWF0aW9uIHdpbGwNCj4+Pj4gY29udmVyZ2UNCj4+Pj4gaW4gdGhlIEwyIG5vcm0sIGJ1 dCBpdCBjYW4ndCBjb252ZXJnZSBpbiBMX2luZmluaXR5Li4NCj4+DQo+PiBJIGRvbid0IGtu b3cgdGhlIGRldGFpbHMsIHNvIEknbSBub3Qgc3VyZSBpdCBtYWtlcyBzZW5zZSwgYnV0IGl0 DQo+PiBsb29rcyB0byBtZSBsaWtlIHRoZSBwcmVzZW5jZSBhbmQgc2l6ZSBvZg0KPj4gb3Zl ci11bmRlcnNob290cyBkZXBlbmRzIG9uIHRoZSBzaXplIG9mIHRoZSBjb2Fyc2UtbGV2ZWwg bWVzaC4gQ291bGQNCj4+IHRoaXMgYmUgcmVsYXRlZCB0byB0aGUgd2F5DQo+PiBoYW5naW5n IG5vZGUgY29uc3RyYWludHMgYXJlIGhhbmRsZWQgKEwyKT8NCj4+IEp1c3QgdG8gZ2V0IG1v cmUgaW5zaWdodDogd2lsbCBhIHVuaWZvcm1seSBBTVIgcmVmaW5lZCBtZXNoIGJlaGF2ZQ0K Pj4gZGlmZmVyZW50bHkgdGhhbiBhIG5vbi1yZWZpbmVkDQo+PiBtZXNoIHdpdGggdGhlIHNh bWUgc2l6ZWQgZWxlbWVudHMgYXMgdGhlIGZpbmUgQU1SIG9uZXM/IEhvdyBtdWNoIG9mDQo+ PiBhbiBpbmZsdWVuY2Ugd2lsbCB0aGUgY29hcnNlLWxldmVsDQo+PiBtZXNoIGhhdmU/DQo+ DQo+IEl0IHNob3VsZG4ndCBkZXBlbmQgb24gd2hhdCBtZXNoIHlvdSBzdGFydCB3aXRoLCB1 bmxlc3MgaXQgd2FzIGNvYXJzZQ0KPiBlbm91Z2ggdG8gaGF2ZSBHYWxlcmtpbi1pbnN0YWJp bGl0eSB0eXBlIG9zY2lsbGF0aW9ucy4gIEluIHRoYXQgY2FzZSwNCj4gbG9jYWwgY2VsbC1S ZXlub2xkcyBudW1iZXIgdmlvbGF0aW9ucyBjYW4gY2F1c2Ugb3Zlci91bmRlcnNob290cyAo Zm9yDQo+IE5hdmllci1TdG9rZXMgb2J2aW91c2x5LCBub3QgU3Rva2VzIGZsb3cpLg0KPg0K PiBJbiBhbnN3ZXIgdG8geW91ciBzZWNvbmQgcXVlc3Rpb24sIGEgInVuaWZvcm1seS1yZWZp bmVkIEFNUiBtZXNoIg0KPiBzaG91bGQgYmVoYXZlIGlkZW50aWNhbGx5IHRvIGEgbm9uLXJl ZmluZWQgbWVzaCB3aXRoIHRoZSBzYW1lIHNpemUNCj4gZWxlbWVudHMuICBJIHdvdWxkIGJl IGludGVyZXN0ZWQgaW4gc2VlaW5nIGEgY2FzZSB3aGVyZSBpdCBkb2VzIG5vdCwNCj4gaWYg eW91IGhhdmUgb25lLg0KPg0KPiAtSg0KPg0KPg0KPg0KPj4gVGhhbmtzIGEgbG90IGZvciB5 b3VyIHRpbWUNCj4+DQo+PiBMdWNhDQo+Pg0KPj4gLS0NCj4+IEx1Y2EgQW50aWdhLCBQaEQN Cj4+IEhlYWQsIE1lZGljYWwgSW1hZ2luZyBVbml0LA0KPj4gQmlvZW5naW5lZXJpbmcgRGVw YXJ0bWVudCwNCj4+IE1hcmlvIE5lZ3JpIEluc3RpdHV0ZQ0KPj4gZW1haWw6IGFudGlnYUBt YXJpb25lZ3JpLml0DQo+PiB3ZWI6IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5p dC9+bHVjYQ0KPj4gbWFpbDogVmlsbGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmljYSAoQkcpLCBJ dGFseQ0KPj4gcGhvbmU6ICszOSAwMzUgNDUzNS0zODENCj4+DQo+Pg0KPj4gT24gQXByIDQs IDIwMDcsIGF0IDQ6MjIgUE0sIEpvaG4gUGV0ZXJzb24gd3JvdGU6DQo+Pg0KPj4+IFJveSBT dG9nbmVyIHdyaXRlczoNCj4+Pj4gT24gV2VkLCA0IEFwciAyMDA3LCBMdWNhIEFudGlnYSB3 cm90ZToNCj4+Pj4NCj4+Pj4+IEkgY291bGQgbGl2ZSB3aXRoIG5vbiB6ZXJvIHZhbHVlcyBv biB0aGUgemVybyB2ZWxvY2l0eSBmYWNlcywgYnV0DQo+Pj4+PiBhcmVuJ3QNCj4+Pj4+IHRo b3NlIGEgYml0IGxhcmdlICgxMCUgb2YgdGhlIHRvcCBmYWNlIHZlbG9jaXR5KT8NCj4+Pj4N Cj4+Pj4gWWVzLCBidXQgdGhlbiBHaWJicycgdHlwZSByaW5naW5nIHVzdWFsbHkgaXMgbGFy Z2UuICBXaGF0J3MgIA0KPj4+PiB3b3JzZTogYXMNCj4+Pj4geW91IHJlZmluZSB0aGUgbWVz aCB0aGUgYm91bmRhcnkgY29uZGl0aW9uIGFwcHJveGltYXRpb24gd2lsbA0KPj4+PiBjb252 ZXJnZQ0KPj4+PiBpbiB0aGUgTDIgbm9ybSwgYnV0IGl0IGNhbid0IGNvbnZlcmdlIGluIExf aW5maW5pdHkuLg0KPj4+Pg0KPj4+Pj4gSSdtIGp1c3Qgd29ycmllZCB0aGF0IHRoZSBzaXR1 YXRpb24gbWlnaHQgZ28gb3V0IG9mIGNvbnRyb2wgaW4NCj4+Pj4+IGNvbXBsaWNhdGVkIGdl b21ldHJpZXMsIHNvIHRoYXQncyB3aHkgSSdtIGEgYml0IHBpY2t5IG9uIHRoaXMNCj4+Pj4+ IHByb2JsZW0uDQo+Pj4+DQo+Pj4+IEl0J3Mgbm90IHRoZSBnZW9tZXRyeSB0aGF0J3MgY29u dHJvbGxpbmcgdGhlIHByb2JsZW0sIGl0J3MgdGhlDQo+Pj4+IGRpc2NvbnRpbnVpdHkgaW4g dGhlIGJvdW5kYXJ5IGNvbmRpdGlvbnMuDQo+Pj4NCj4+Pj4gSSB0aGluayBKb2huJ3MgaGFk IHNvbWV3aGF0IHNtb290aGVyIHJlc3VsdHMgYnkgdXNpbmcgYW4gSDEgaW5zdGVhZA0KPj4+ PiBvZiBMMiBib3VuZGFyeSBwZW5hbHR5LCBidXQgd2hlbiB5b3UgdHJ5IHRvIGZvcmNlIGEg Y29udGludW91cw0KPj4+PiBhcHByb3hpbWF0aW9uIGZ1bmN0aW9uIHRvIHRha2Ugb24gZGlz Y29udGludW91cyB2YWx1ZXMsIHRoZXJlJ3MNCj4+Pj4gcmVhbGx5IG5vIGdvb2Qgd2F5IGZv ciBpdCB0byByZWFjdC4NCj4+Pg0KPj4+IEFjdHVhbGx5LCBJIGNvdWxkbid0IGdldCB0aGUg SDEgcHJvamVjdGlvbiB0byB3b3JrIChpbiAyRCkuICBJIHRyaWVkDQo+Pj4gcGVuYWxpemlu ZyB0aGUgdGFuZ2VudGlhbCBkZXJpdmF0aXZlcywgdG8gZS5nLiBlbmZvcmNlIGR1L2R4PWR2 L2R4PTANCj4+PiBhbG9uZyB0aGUgbGlkLg0KPj4+DQo+Pj4gT25lIHRoaW5nIHRoYXQgc2Vl bWVkIHRvIGhlbHAgYSBiaXQgKGF0IGxlYXN0IGluIDJEKSB3YXMgdG8gdXNlIHRoZQ0KPj4+ ICJsdW1wZWQiIEwyIHByb2plY3Rpb24gKGUuZy4gZXgxMykuICBJZiBtZW1vcnkgc2VydmVz LCB0aGF0IHNvbHV0aW9uDQo+Pj4gImxvb2tlZCIgc2xpZ2h0bHkgYmV0dGVyIChhdCBsZWFz dCBpbiAyRCkuDQo+Pj4NCj4+Pj4gTWFueSBwZW9wbGUgZ2l2ZSB1cCBhbmQganVzdCByZWd1 bGFyaXplIHRoZSBwcm9ibGVtIGJvdW5kYXJ5DQo+Pj4+IGNvbmRpdGlvbnMuDQo+Pj4NCj4+ PiBJbmRlZWQsIHRoZSBoeXBlcmJvbGljIHRhbmdlbnQtdHlwZSByZWd1bGFyaXplZCBib3Vu ZGFyeSBjb25kaXRpb25zDQo+Pj4gc2VlbSB0byBiZQ0KPj4+IGZhaXJseSBzdGFuZGFyZCBp biB0aGUgbGl0ZXJhdHVyZSBmb3IgdGhpcyB0eXBlIG9mIHByb2JsZW0uICBJZiB3ZQ0KPj4+ IGp1c3QNCj4+PiB3YW50IHRvIGJlIHN1cmUgU3Rva2VzK0FNUitUZXRzIGlzIHdvcmtpbmcs IGxldCdzIHRyeSBhIHRlc3QgcHJvYmxlbQ0KPj4+IHdpdGggY29udGludW91cyBkYXRhPw0K Pj4+DQo+Pj4gLUoNCj4NCj4gLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSANCj4gLS0tDQo+IFRha2UgU3Vy dmV5cy4gRWFybiBDYXNoLiBJbmZsdWVuY2UgdGhlIEZ1dHVyZSBvZiBJVA0KPiBKb2luIFNv dXJjZUZvcmdlLm5ldCdzIFRlY2hzYXkgcGFuZWwgYW5kIHlvdSdsbCBnZXQgdGhlIGNoYW5j ZSB0byAgDQo+IHNoYXJlIHlvdXINCj4gb3BpbmlvbnMgb24gSVQgJiBidXNpbmVzcyB0b3Bp Y3MgdGhyb3VnaCBicmllZiBzdXJ2ZXlzLWFuZCBlYXJuIGNhc2gNCj4gaHR0cDovL3d3dy50 ZWNoc2F5LmNvbS9kZWZhdWx0LnBocD8gDQo+IHBhZ2U9am9pbi5waHAmcD1zb3VyY2Vmb3Jn ZSZDSUQ9REVWREVWDQo+IF9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fDQo+IExpYm1lc2gtdXNlcnMgbWFpbGluZyBsaXN0DQo+IExpYm1lc2gtdXNl cnNAbGlzdHMuc291cmNlZm9yZ2UubmV0DQo+IGh0dHBzOi8vbGlzdHMuc291cmNlZm9yZ2Uu bmV0L2xpc3RzL2xpc3RpbmZvL2xpYm1lc2gtdXNlcnMNCg0KDQoNCg0KLS0tDQpEZXN0aW5h IGlsIHR1byA1IHBlciBtaWxsZSBkZWxsJ0lSUEVGICAoc3VsIG1vZC4gNzMwIG8gbW9kLiBV TklDTyBvDQptb2QuIENVRCkgZmlybWFuZG8gZSBpbmRpY2FuZG8gaWwgbm9zdHJvIGNvZGlj ZSBmaXNjYWxlIDAzMjU0MjEwMTUwDQpuZWwgcmlxdWFkcm8gICAiZmluYW56aWFtZW50byBh Z2xpIGVudGkgZGVsbGEgcmljZXJjYSBzY2llbnRpZmljYSBlDQpkZWxsJ3VuaXZlcnNpdGEn IiAgIHBlciBhaXV0YXJlIGEgbWFudGVuZXJlIGluZGlwZW5kZW50ZSBsYSByaWNlcmNhDQpz Y2llbnRpZmljYSBkZWxsJ0lzdGl0dXRvIE1hcmlvIE5lZ3JpLCB1bmEgZm9uZGF6aW9uZSBw cml2YXRhIHNlbnphDQpzY29wbyBkaSBsdWNybyBjaGUgZGEgb2x0cmUgNDAgYW5uaSBvcGVy YSBuZWxsJ2ludGVyZXNzZSBkZWdsaQ0KYW1tYWxhdGkuDQoNClBlciBtYWdnaW9yaSBpbmZv cm1hemlvbmk6DQpJc3RpdHV0byBNYXJpbyBOZWdyaSwgVmlhIEVyaXRyZWEgNjIgLSAyMDE1 NyBNaWxhbm8NClRlbDogKzM5IDAyIDM5MDE0MzE3IC0gRmF4OiArMzkgMDIgMzU0NjI3NyAr MzkgMDIgMzkwMDE5MTgNCkludGVybmV0OiB3d3cubWFyaW9uZWdyaS5pdCwgbW5lZ3JpQG1h cmlvbmVncmkuaXQ= ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-11 14:04 Attachments: shock_picture.pdf      Message as HTML ```Hi Luca, I notice that only for the Lumped Hexes is the maximum velocity magnitude=1. Is there still a 19% overshoot for the Lumped Tets? It looks like perhaps the variable ranges just need to be reset in the last picture. Is your conclusion that adaptivity is working OK in LibMesh? It seems that applying the lumped penalty BC formulation for discontinuous boundary conditions is a reasonable rule of thumb to follow. It's kind of like choosing which type of approximation to a "shock" one prefers. (See attached figure.) ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-04-11 15:24 ```Luca Antiga writes: > Yes, we noticed it too late: we didn't change the scalar bar in the > lumped tets... > Anyway, we confirm that there's no overshoot with the lumped tets > case (you can see the top vectors are shown in orange). > The interpretation you give in the figure is quite effective. > > In the cube you sent last week, what puzzled me is that in the AMR > refined cube it almost looks like you get exact bc values > at the nodes of the original mesh, while in the refined nodes you get > the oscillations (look at box 2 in the figure). Is this just due > to symmetry or to the presence of the unrefined bulk mesh in the > interior? Or it's an effect of the L2 constraints on the hanging nodes? > I'd like to hear an opinion from you guys. I think I see the node you are referring to. I put a circle around it in the picture here: http://www.cfdlab.ae.utexas.edu/~peterson/hanging.png This hanging node is constrained to take on 1/2 the x-velocity value of the lid (1.0) and the side wall (0.0). So it obtains a value of roughly 1/2. I think this is correct from the standpoint that this is what the library implements, but whether or not it is correct in the sense of "this is what you want to see" is debatable. In your refined hex mesh there is no such coarse element sitting on the boundary, so you don't see this effect there. > Anyway, once one understands the subtleties of AMR and penalty > conditions, it looks like 3D AMR is working well in libmesh, > both for hexas and tets. > > We're now running a case on a 3D tet mesh of a real vessel. We'll > keep you posted on the advancements. > Once thing we anticipate is that level-one refinement is not always > granted: even though we refine with the maintain level one > flag set to true, we get a two-level jump on a few neighboring faces. This apparent 2-level refinement may be due to the fact that we plot 10-node Tets as 8 linear tetrahedra in GMV. So for example in the figures on your webpage it looks like level-1 is enforced. -John > > On Apr 11, 2007, at 4:03 PM, John Peterson wrote: > > > Hi Luca, > > > > I notice that only for the Lumped Hexes is the maximum velocity > > magnitude=1. > > Is there still a 19% overshoot for the Lumped Tets? It looks like > > perhaps > > the variable ranges just need to be reset in the last picture. Is > > your > > conclusion that adaptivity is working OK in LibMesh? > > > > It seems that applying the lumped penalty BC formulation for > > discontinuous boundary > > conditions is a reasonable rule of thumb to follow. It's kind of > > like choosing > > which type of approximation to a "shock" one prefers. (See > > attached figure.) > > > > > > > > > > -John > > > > > > > > Luca Antiga writes: > >> Hi guys, > >> as promised we took a few images of the 3D lid-driven cavity > >> showing the difference it makes > >> to impose L2 vs lumped penalty boundary conditions. > >> You can take a look at them here > >> > >> http://villacamozzi.marionegri.it/~luca/HexLid3dL2.png > >> http://villacamozzi.marionegri.it/~luca/HexLid3dLumped.png > >> http://villacamozzi.marionegri.it/~luca/TetLid3dL2.png > >> http://villacamozzi.marionegri.it/~luca/TetLid3dlumped.png > >> > >> where the names of the images explain which case is which. > >> As you can see, imposing lumped boundary conditions does make a > >> difference. > >> In particular, apart from the spurious non-zero velocities on the > >> side walls, the top > >> velocity is 1 for lumped bcs, while it overshoots by 20% in case of > >> L2 in case of Tet10 > >> elements. We get a bit less pronounced overshoots (15%) with hexas > >> and L2. > >> > >> We tried lowering the absolute threshold of the linear system > >> solvers, with no appreciable > >> changes. > >> > >> Luca > >> > >> -- > >> Luca Antiga, PhD > >> Head, Medical Imaging Unit, > >> Bioengineering Department, > >> Mario Negri Institute > >> email: antiga@... > >> web: http://villacamozzi.marionegri.it/~luca > >> mail: Villa Camozzi, 24020, Ranica (BG), Italy > >> phone: +39 035 4535-381 > >> > >> > >> On Apr 4, 2007, at 5:09 PM, John Peterson wrote: > >> > >>> Luca Antiga writes: > >>>> Hi, > >>>>> One thing that seemed to help a bit (at least in 2D) was to use > >>>>> the > >>>>> "lumped" L2 projection (e.g. ex13). If memory serves, that > >>>>> solution > >>>>> "looked" slightly better (at least in 2D). > >>>> We confirm that this helps also in 3D. We'll show you images as > >>>> soon > >>>> as Lorenzo is around. > >>>> The situation changes sensibly, you see much fewer non-zero vectors > >>>> on the no-slip faces. > >>>> > >>>> Ultimately we'll work with blood vessels, so we won't have > >>>> discontinuous boundary conditions. > >>>> However, I can tell you that we tried on a vessel with parabolic > >>>> inlet conditions (that go to zero > >>>> at the wall, so no discontinuity). With L2 boundary conditions, the > >>>> first ring of refined nodes on the > >>>> no-slip side wall connected to the inlet face had non-zero velocity > >>>> vectors pointing opposite > >>>> to the inlet flow direction. > >>> > >>> Hmm... and the lumped L2-projection looks slightly better than that? > >>> I will try implementing the "pinwheel" type forcing function for the > >>> Stokes problem with homogeneous zero Dirichlet BCs in 2D using > >>> adaptivity, > >>> and see what that gives us. > >>> > >>>>>> Yes, but then Gibbs' type ringing usually is large. What's > >>>>>> worse: as > >>>>>> you refine the mesh the boundary condition approximation will > >>>>>> converge > >>>>>> in the L2 norm, but it can't converge in L_infinity.. > >>>> > >>>> I don't know the details, so I'm not sure it makes sense, but it > >>>> looks to me like the presence and size of > >>>> over-undershoots depends on the size of the coarse-level mesh. > >>>> Could > >>>> this be related to the way > >>>> hanging node constraints are handled (L2)? > >>>> Just to get more insight: will a uniformly AMR refined mesh behave > >>>> differently than a non-refined > >>>> mesh with the same sized elements as the fine AMR ones? How much of > >>>> an influence will the coarse-level > >>>> mesh have? > >>> > >>> It shouldn't depend on what mesh you start with, unless it was > >>> coarse > >>> enough to have Galerkin-instability type oscillations. In that > >>> case, > >>> local cell-Reynolds number violations can cause over/undershoots > >>> (for > >>> Navier-Stokes obviously, not Stokes flow). > >>> > >>> In answer to your second question, a "uniformly-refined AMR mesh" > >>> should behave identically to a non-refined mesh with the same size > >>> elements. I would be interested in seeing a case where it does not, > >>> if you have one. > >>> > >>> -J > >>> > >>> > >>> > >>>> Thanks a lot for your time > >>>> > >>>> Luca > >>>> > >>>> -- > >>>> Luca Antiga, PhD > >>>> Head, Medical Imaging Unit, > >>>> Bioengineering Department, > >>>> Mario Negri Institute > >>>> email: antiga@... > >>>> web: http://villacamozzi.marionegri.it/~luca > >>>> mail: Villa Camozzi, 24020, Ranica (BG), Italy > >>>> phone: +39 035 4535-381 > >>>> > >>>> > >>>> On Apr 4, 2007, at 4:22 PM, John Peterson wrote: > >>>> > >>>>> Roy Stogner writes: > >>>>>> On Wed, 4 Apr 2007, Luca Antiga wrote: > >>>>>> > >>>>>>> I could live with non zero values on the zero velocity faces, > >>>>>>> but > >>>>>>> aren't > >>>>>>> those a bit large (10% of the top face velocity)? > >>>>>> > >>>>>> Yes, but then Gibbs' type ringing usually is large. What's > >>>>>> worse: as > >>>>>> you refine the mesh the boundary condition approximation will > >>>>>> converge > >>>>>> in the L2 norm, but it can't converge in L_infinity.. > >>>>>> > >>>>>>> I'm just worried that the situation might go out of control in > >>>>>>> complicated geometries, so that's why I'm a bit picky on this > >>>>>>> problem. > >>>>>> > >>>>>> It's not the geometry that's controlling the problem, it's the > >>>>>> discontinuity in the boundary conditions. > >>>>> > >>>>>> I think John's had somewhat smoother results by using an H1 > >>>>>> instead > >>>>>> of L2 boundary penalty, but when you try to force a continuous > >>>>>> approximation function to take on discontinuous values, there's > >>>>>> really no good way for it to react. > >>>>> > >>>>> Actually, I couldn't get the H1 projection to work (in 2D). I > >>>>> tried > >>>>> penalizing the tangential derivatives, to e.g. enforce du/dx=dv/ > >>>>> dx=0 > >>>>> along the lid. > >>>>> > >>>>> One thing that seemed to help a bit (at least in 2D) was to use > >>>>> the > >>>>> "lumped" L2 projection (e.g. ex13). If memory serves, that > >>>>> solution > >>>>> "looked" slightly better (at least in 2D). > >>>>> > >>>>>> Many people give up and just regularize the problem boundary > >>>>>> conditions. > >>>>> > >>>>> Indeed, the hyperbolic tangent-type regularized boundary > >>>>> conditions > >>>>> seem to be > >>>>> fairly standard in the literature for this type of problem. If we > >>>>> just > >>>>> want to be sure Stokes+AMR+Tets is working, let's try a test > >>>>> problem > >>>>> with continuous data? > >>>>> > >>>>> -J ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-04-11 16:36 ```On Wed, 11 Apr 2007, John Peterson wrote: > This apparent 2-level refinement may be due to the fact that we plot > 10-node Tets as 8 linear tetrahedra in GMV. So for example in the > figures on your webpage it looks like level-1 is enforced. I don't think our plotting decimation should ever give anything that looks like a level-2 hanging node on a level-1 mesh. Let us know if you ever do see such a thing, especially if you can code up a repeatable example of it. I think I refactored the h refinement code a bit while I was adding p refinement last year, and although by now the result is pretty well-tested on triangles, quads, and cubes I wouldn't want to guarantee that I didn't introduce some subtle tet-specific bug. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-12 07:42 ```SGV5IEpvaG4sDQoNCj4gVGhpcyBoYW5naW5nIG5vZGUgaXMgY29uc3RyYWluZWQgdG8gdGFr ZSBvbiAxLzIgdGhlIHgtdmVsb2NpdHkgdmFsdWUNCj4gb2YgdGhlIGxpZCAoMS4wKSBhbmQg dGhlIHNpZGUgd2FsbCAoMC4wKS4gIFNvIGl0IG9idGFpbnMgYSB2YWx1ZSBvZg0KPiByb3Vn aGx5IDEvMi4gIEkgdGhpbmsgdGhpcyBpcyBjb3JyZWN0IGZyb20gdGhlIHN0YW5kcG9pbnQg dGhhdCB0aGlzDQo+IGlzIHdoYXQgdGhlIGxpYnJhcnkgaW1wbGVtZW50cywgYnV0IHdoZXRo ZXIgb3Igbm90IGl0IGlzIGNvcnJlY3QNCj4gaW4gdGhlIHNlbnNlIG9mICJ0aGlzIGlzIHdo YXQgeW91IHdhbnQgdG8gc2VlIiBpcyBkZWJhdGFibGUuICBJbiB5b3VyDQo+IHJlZmluZWQg aGV4IG1lc2ggdGhlcmUgaXMgbm8gc3VjaCBjb2Fyc2UgZWxlbWVudCBzaXR0aW5nIG9uIHRo ZSAgDQo+IGJvdW5kYXJ5LA0KPiBzbyB5b3UgZG9uJ3Qgc2VlIHRoaXMgZWZmZWN0IHRoZXJl Lg0KDQpJIHNlZSB0aGUgcG9pbnQgbm93LiBUaGFua3MgZm9yIHRoZSBleHBsYW5hdGlvbi4g TG9yZW56byBmb3VuZCBhIHNldCAgDQpvZiByZWZpbmVtZW50DQpwYXJhbWV0ZXJzIHRoYXQg cHJldmVudHMgdGhpcyB3aXRoIHRldHMgdG9vLiBJZiBubyBoYW5naW5nIG5vZGVzIHNpdCAg DQpvbiBlZGdlcyBjb25uZWN0ZWQNCnRvIHRoZSB0b3AgYm91bmRhcnksIG5vIHNwdXJpb3Vz IHZlbG9jaXRpZXMgYXJlIGdlbmVyYXRlZC4gTWFrZXMgc2Vuc2UuDQoNCg0KLS0NCkx1Y2Eg QW50aWdhLCBQaEQNCkhlYWQsIE1lZGljYWwgSW1hZ2luZyBVbml0LA0KQmlvZW5naW5lZXJp bmcgRGVwYXJ0bWVudCwNCk1hcmlvIE5lZ3JpIEluc3RpdHV0ZQ0KZW1haWw6IGFudGlnYUBt YXJpb25lZ3JpLml0DQp3ZWI6IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+ bHVjYQ0KbWFpbDogVmlsbGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmljYSAoQkcpLCBJdGFseQ0K cGhvbmU6ICszOSAwMzUgNDUzNS0zODENCg0KDQpPbiBBcHIgMTEsIDIwMDcsIGF0IDU6MjQg UE0sIEpvaG4gUGV0ZXJzb24gd3JvdGU6DQoNCj4gTHVjYSBBbnRpZ2Egd3JpdGVzOg0KPj4g WWVzLCB3ZSBub3RpY2VkIGl0IHRvbyBsYXRlOiB3ZSBkaWRuJ3QgY2hhbmdlIHRoZSBzY2Fs YXIgYmFyIGluIHRoZQ0KPj4gbHVtcGVkIHRldHMuLi4NCj4+IEFueXdheSwgd2UgY29uZmly bSB0aGF0IHRoZXJlJ3Mgbm8gb3ZlcnNob290IHdpdGggdGhlIGx1bXBlZCB0ZXRzDQo+PiBj YXNlICh5b3UgY2FuIHNlZSB0aGUgdG9wIHZlY3RvcnMgYXJlIHNob3duIGluIG9yYW5nZSku DQo+PiBUaGUgaW50ZXJwcmV0YXRpb24geW91IGdpdmUgaW4gdGhlIGZpZ3VyZSBpcyBxdWl0 ZSBlZmZlY3RpdmUuDQo+Pg0KPj4gSW4gdGhlIGN1YmUgeW91IHNlbnQgbGFzdCB3ZWVrLCB3 aGF0IHB1enpsZWQgbWUgaXMgdGhhdCBpbiB0aGUgQU1SDQo+PiByZWZpbmVkIGN1YmUgaXQg YWxtb3N0IGxvb2tzIGxpa2UgeW91IGdldCBleGFjdCBiYyB2YWx1ZXMNCj4+IGF0IHRoZSBu b2RlcyBvZiB0aGUgb3JpZ2luYWwgbWVzaCwgd2hpbGUgaW4gdGhlIHJlZmluZWQgbm9kZXMg eW91IGdldA0KPj4gdGhlIG9zY2lsbGF0aW9ucyAobG9vayBhdCBib3ggMiBpbiB0aGUgZmln dXJlKS4gSXMgdGhpcyBqdXN0IGR1ZQ0KPj4gdG8gc3ltbWV0cnkgb3IgdG8gdGhlIHByZXNl bmNlIG9mIHRoZSB1bnJlZmluZWQgYnVsayBtZXNoIGluIHRoZQ0KPj4gaW50ZXJpb3I/IE9y IGl0J3MgYW4gZWZmZWN0IG9mIHRoZSBMMiBjb25zdHJhaW50cyBvbiB0aGUgaGFuZ2luZyAg DQo+PiBub2Rlcz8NCj4+IEknZCBsaWtlIHRvIGhlYXIgYW4gb3BpbmlvbiBmcm9tIHlvdSBn dXlzLg0KPg0KPiBJIHRoaW5rIEkgc2VlIHRoZSBub2RlIHlvdSBhcmUgcmVmZXJyaW5nIHRv LiAgSSBwdXQgYSBjaXJjbGUgYXJvdW5kICANCj4gaXQgaW4NCj4gdGhlIHBpY3R1cmUgaGVy ZToNCj4NCj4gaHR0cDovL3d3dy5jZmRsYWIuYWUudXRleGFzLmVkdS9+cGV0ZXJzb24vaGFu Z2luZy5wbmcNCj4NCj4gVGhpcyBoYW5naW5nIG5vZGUgaXMgY29uc3RyYWluZWQgdG8gdGFr ZSBvbiAxLzIgdGhlIHgtdmVsb2NpdHkgdmFsdWUNCj4gb2YgdGhlIGxpZCAoMS4wKSBhbmQg dGhlIHNpZGUgd2FsbCAoMC4wKS4gIFNvIGl0IG9idGFpbnMgYSB2YWx1ZSBvZg0KPiByb3Vn aGx5IDEvMi4gIEkgdGhpbmsgdGhpcyBpcyBjb3JyZWN0IGZyb20gdGhlIHN0YW5kcG9pbnQg dGhhdCB0aGlzDQo+IGlzIHdoYXQgdGhlIGxpYnJhcnkgaW1wbGVtZW50cywgYnV0IHdoZXRo ZXIgb3Igbm90IGl0IGlzIGNvcnJlY3QNCj4gaW4gdGhlIHNlbnNlIG9mICJ0aGlzIGlzIHdo YXQgeW91IHdhbnQgdG8gc2VlIiBpcyBkZWJhdGFibGUuICBJbiB5b3VyDQo+IHJlZmluZWQg aGV4IG1lc2ggdGhlcmUgaXMgbm8gc3VjaCBjb2Fyc2UgZWxlbWVudCBzaXR0aW5nIG9uIHRo ZSAgDQo+IGJvdW5kYXJ5LA0KPiBzbyB5b3UgZG9uJ3Qgc2VlIHRoaXMgZWZmZWN0IHRoZXJl Lg0KPg0KPj4gQW55d2F5LCBvbmNlIG9uZSB1bmRlcnN0YW5kcyB0aGUgc3VidGxldGllcyBv ZiBBTVIgYW5kIHBlbmFsdHkNCj4+IGNvbmRpdGlvbnMsIGl0IGxvb2tzIGxpa2UgM0QgQU1S IGlzIHdvcmtpbmcgd2VsbCBpbiBsaWJtZXNoLA0KPj4gYm90aCBmb3IgaGV4YXMgYW5kIHRl dHMuDQo+Pg0KPj4gV2UncmUgbm93IHJ1bm5pbmcgYSBjYXNlIG9uIGEgM0QgdGV0IG1lc2gg b2YgYSByZWFsIHZlc3NlbC4gV2UnbGwNCj4+IGtlZXAgeW91IHBvc3RlZCBvbiB0aGUgYWR2 YW5jZW1lbnRzLg0KPj4gT25jZSB0aGluZyB3ZSBhbnRpY2lwYXRlIGlzIHRoYXQgbGV2ZWwt b25lIHJlZmluZW1lbnQgaXMgbm90IGFsd2F5cw0KPj4gZ3JhbnRlZDogZXZlbiB0aG91Z2gg d2UgcmVmaW5lIHdpdGggdGhlIG1haW50YWluIGxldmVsIG9uZQ0KPj4gZmxhZyBzZXQgdG8g dHJ1ZSwgd2UgZ2V0IGEgdHdvLWxldmVsIGp1bXAgb24gYSBmZXcgbmVpZ2hib3JpbmcgZmFj ZXMuDQo+DQo+IFRoaXMgYXBwYXJlbnQgMi1sZXZlbCByZWZpbmVtZW50IG1heSBiZSBkdWUg dG8gdGhlIGZhY3QgdGhhdCB3ZSBwbG90DQo+IDEwLW5vZGUgVGV0cyBhcyA4IGxpbmVhciB0 ZXRyYWhlZHJhIGluIEdNVi4gIFNvIGZvciBleGFtcGxlIGluIHRoZQ0KPiBmaWd1cmVzIG9u IHlvdXIgd2VicGFnZSBpdCBsb29rcyBsaWtlIGxldmVsLTEgaXMgZW5mb3JjZWQuDQo+DQo+ IC1Kb2huDQo+DQo+DQo+Pg0KPj4gT24gQXByIDExLCAyMDA3LCBhdCA0OjAzIFBNLCBKb2hu IFBldGVyc29uIHdyb3RlOg0KPj4NCj4+PiBIaSBMdWNhLA0KPj4+DQo+Pj4gSSBub3RpY2Ug dGhhdCBvbmx5IGZvciB0aGUgTHVtcGVkIEhleGVzIGlzIHRoZSBtYXhpbXVtIHZlbG9jaXR5 DQo+Pj4gbWFnbml0dWRlPTEuDQo+Pj4gSXMgdGhlcmUgc3RpbGwgYSAxOSUgb3ZlcnNob290 IGZvciB0aGUgTHVtcGVkIFRldHM/ICBJdCBsb29rcyBsaWtlDQo+Pj4gcGVyaGFwcw0KPj4+ IHRoZSB2YXJpYWJsZSByYW5nZXMganVzdCBuZWVkIHRvIGJlIHJlc2V0IGluIHRoZSBsYXN0 IHBpY3R1cmUuICBJcw0KPj4+IHlvdXINCj4+PiBjb25jbHVzaW9uIHRoYXQgYWRhcHRpdml0 eSBpcyB3b3JraW5nIE9LIGluIExpYk1lc2g/DQo+Pj4NCj4+PiBJdCBzZWVtcyB0aGF0IGFw cGx5aW5nIHRoZSBsdW1wZWQgcGVuYWx0eSBCQyBmb3JtdWxhdGlvbiBmb3INCj4+PiBkaXNj b250aW51b3VzIGJvdW5kYXJ5DQo+Pj4gY29uZGl0aW9ucyBpcyBhIHJlYXNvbmFibGUgcnVs ZSBvZiB0aHVtYiB0byBmb2xsb3cuICBJdCdzIGtpbmQgb2YNCj4+PiBsaWtlIGNob29zaW5n DQo+Pj4gd2hpY2ggdHlwZSBvZiBhcHByb3hpbWF0aW9uIHRvIGEgInNob2NrIiBvbmUgcHJl ZmVycy4gIChTZWUNCj4+PiBhdHRhY2hlZCBmaWd1cmUuKQ0KPj4+DQo+Pj4gPHNob2NrX3Bp Y3R1cmUucGRmPg0KPj4+DQo+Pj4NCj4+PiAtSm9obg0KPj4+DQo+Pj4NCj4+Pg0KPj4+IEx1 Y2EgQW50aWdhIHdyaXRlczoNCj4+Pj4gSGkgZ3V5cywNCj4+Pj4gICBhcyBwcm9taXNlZCB3 ZSB0b29rIGEgZmV3IGltYWdlcyBvZiB0aGUgM0QgbGlkLWRyaXZlbiBjYXZpdHkNCj4+Pj4g c2hvd2luZyB0aGUgZGlmZmVyZW5jZSBpdCBtYWtlcw0KPj4+PiB0byBpbXBvc2UgTDIgdnMg bHVtcGVkIHBlbmFsdHkgYm91bmRhcnkgY29uZGl0aW9ucy4NCj4+Pj4gWW91IGNhbiB0YWtl IGEgbG9vayBhdCB0aGVtIGhlcmUNCj4+Pj4NCj4+Pj4gaHR0cDovL3ZpbGxhY2Ftb3p6aS5t YXJpb25lZ3JpLml0L35sdWNhL0hleExpZDNkTDIucG5nDQo+Pj4+IGh0dHA6Ly92aWxsYWNh bW96emkubWFyaW9uZWdyaS5pdC9+bHVjYS9IZXhMaWQzZEx1bXBlZC5wbmcNCj4+Pj4gaHR0 cDovL3ZpbGxhY2Ftb3p6aS5tYXJpb25lZ3JpLml0L35sdWNhL1RldExpZDNkTDIucG5nDQo+ Pj4+IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVjYS9UZXRMaWQzZGx1 bXBlZC5wbmcNCj4+Pj4NCj4+Pj4gd2hlcmUgdGhlIG5hbWVzIG9mIHRoZSBpbWFnZXMgZXhw bGFpbiB3aGljaCBjYXNlIGlzIHdoaWNoLg0KPj4+PiBBcyB5b3UgY2FuIHNlZSwgaW1wb3Np bmcgbHVtcGVkIGJvdW5kYXJ5IGNvbmRpdGlvbnMgZG9lcyBtYWtlIGENCj4+Pj4gZGlmZmVy ZW5jZS4NCj4+Pj4gSW4gcGFydGljdWxhciwgYXBhcnQgZnJvbSB0aGUgc3B1cmlvdXMgbm9u LXplcm8gdmVsb2NpdGllcyBvbiB0aGUNCj4+Pj4gc2lkZSB3YWxscywgdGhlIHRvcA0KPj4+ PiB2ZWxvY2l0eSBpcyAxIGZvciBsdW1wZWQgYmNzLCB3aGlsZSBpdCBvdmVyc2hvb3RzIGJ5 IDIwJSBpbiBjYXNlIG9mDQo+Pj4+IEwyIGluIGNhc2Ugb2YgVGV0MTANCj4+Pj4gZWxlbWVu dHMuIFdlIGdldCBhIGJpdCBsZXNzIHByb25vdW5jZWQgb3ZlcnNob290cyAoMTUlKSB3aXRo IGhleGFzDQo+Pj4+IGFuZCBMMi4NCj4+Pj4NCj4+Pj4gV2UgdHJpZWQgbG93ZXJpbmcgdGhl IGFic29sdXRlIHRocmVzaG9sZCBvZiB0aGUgbGluZWFyIHN5c3RlbQ0KPj4+PiBzb2x2ZXJz LCB3aXRoIG5vIGFwcHJlY2lhYmxlDQo+Pj4+IGNoYW5nZXMuDQo+Pj4+DQo+Pj4+IEx1Y2EN Cj4+Pj4NCj4+Pj4gLS0NCj4+Pj4gTHVjYSBBbnRpZ2EsIFBoRA0KPj4+PiBIZWFkLCBNZWRp Y2FsIEltYWdpbmcgVW5pdCwNCj4+Pj4gQmlvZW5naW5lZXJpbmcgRGVwYXJ0bWVudCwNCj4+ Pj4gTWFyaW8gTmVncmkgSW5zdGl0dXRlDQo+Pj4+IGVtYWlsOiBhbnRpZ2FAbWFyaW9uZWdy aS5pdA0KPj4+PiB3ZWI6IGh0dHA6Ly92aWxsYWNhbW96emkubWFyaW9uZWdyaS5pdC9+bHVj YQ0KPj4+PiBtYWlsOiBWaWxsYSBDYW1venppLCAyNDAyMCwgUmFuaWNhIChCRyksIEl0YWx5 DQo+Pj4+IHBob25lOiArMzkgMDM1IDQ1MzUtMzgxDQo+Pj4+DQo+Pj4+DQo+Pj4+IE9uIEFw ciA0LCAyMDA3LCBhdCA1OjA5IFBNLCBKb2huIFBldGVyc29uIHdyb3RlOg0KPj4+Pg0KPj4+ Pj4gTHVjYSBBbnRpZ2Egd3JpdGVzOg0KPj4+Pj4+IEhpLA0KPj4+Pj4+PiBPbmUgdGhpbmcg dGhhdCBzZWVtZWQgdG8gaGVscCBhIGJpdCAoYXQgbGVhc3QgaW4gMkQpIHdhcyB0byB1c2UN Cj4+Pj4+Pj4gdGhlDQo+Pj4+Pj4+ICJsdW1wZWQiIEwyIHByb2plY3Rpb24gKGUuZy4gZXgx MykuICBJZiBtZW1vcnkgc2VydmVzLCB0aGF0DQo+Pj4+Pj4+IHNvbHV0aW9uDQo+Pj4+Pj4+ ICJsb29rZWQiIHNsaWdodGx5IGJldHRlciAoYXQgbGVhc3QgaW4gMkQpLg0KPj4+Pj4+IFdl IGNvbmZpcm0gdGhhdCB0aGlzIGhlbHBzIGFsc28gaW4gM0QuIFdlJ2xsIHNob3cgeW91IGlt YWdlcyBhcw0KPj4+Pj4+IHNvb24NCj4+Pj4+PiBhcyBMb3JlbnpvIGlzIGFyb3VuZC4NCj4+ Pj4+PiBUaGUgc2l0dWF0aW9uIGNoYW5nZXMgc2Vuc2libHksIHlvdSBzZWUgbXVjaCBmZXdl ciBub24temVybyAgDQo+Pj4+Pj4gdmVjdG9ycw0KPj4+Pj4+IG9uIHRoZSBuby1zbGlwIGZh Y2VzLg0KPj4+Pj4+DQo+Pj4+Pj4gVWx0aW1hdGVseSB3ZSdsbCB3b3JrIHdpdGggYmxvb2Qg dmVzc2Vscywgc28gd2Ugd29uJ3QgaGF2ZQ0KPj4+Pj4+IGRpc2NvbnRpbnVvdXMgYm91bmRh cnkgY29uZGl0aW9ucy4NCj4+Pj4+PiBIb3dldmVyLCBJIGNhbiB0ZWxsIHlvdSB0aGF0IHdl IHRyaWVkIG9uIGEgdmVzc2VsIHdpdGggcGFyYWJvbGljDQo+Pj4+Pj4gaW5sZXQgY29uZGl0 aW9ucyAodGhhdCBnbyB0byB6ZXJvDQo+Pj4+Pj4gYXQgdGhlIHdhbGwsIHNvIG5vIGRpc2Nv bnRpbnVpdHkpLiBXaXRoIEwyIGJvdW5kYXJ5ICANCj4+Pj4+PiBjb25kaXRpb25zLCB0aGUN Cj4+Pj4+PiBmaXJzdCByaW5nIG9mIHJlZmluZWQgbm9kZXMgb24gdGhlDQo+Pj4+Pj4gbm8t c2xpcCBzaWRlIHdhbGwgY29ubmVjdGVkIHRvIHRoZSBpbmxldCBmYWNlIGhhZCBub24temVy byAgDQo+Pj4+Pj4gdmVsb2NpdHkNCj4+Pj4+PiB2ZWN0b3JzIHBvaW50aW5nIG9wcG9zaXRl DQo+Pj4+Pj4gdG8gdGhlIGlubGV0IGZsb3cgZGlyZWN0aW9uLg0KPj4+Pj4NCj4+Pj4+IEht bS4uLiBhbmQgdGhlIGx1bXBlZCBMMi1wcm9qZWN0aW9uIGxvb2tzIHNsaWdodGx5IGJldHRl ciB0aGFuICANCj4+Pj4+IHRoYXQ/DQo+Pj4+PiBJIHdpbGwgdHJ5IGltcGxlbWVudGluZyB0 aGUgInBpbndoZWVsIiB0eXBlIGZvcmNpbmcgZnVuY3Rpb24gIA0KPj4+Pj4gZm9yIHRoZQ0K Pj4+Pj4gU3Rva2VzIHByb2JsZW0gd2l0aCBob21vZ2VuZW91cyB6ZXJvIERpcmljaGxldCBC Q3MgaW4gMkQgdXNpbmcNCj4+Pj4+IGFkYXB0aXZpdHksDQo+Pj4+PiBhbmQgc2VlIHdoYXQg dGhhdCBnaXZlcyB1cy4NCj4+Pj4+DQo+Pj4+Pj4+PiBZZXMsIGJ1dCB0aGVuIEdpYmJzJyB0 eXBlIHJpbmdpbmcgdXN1YWxseSBpcyBsYXJnZS4gIFdoYXQncw0KPj4+Pj4+Pj4gd29yc2U6 IGFzDQo+Pj4+Pj4+PiB5b3UgcmVmaW5lIHRoZSBtZXNoIHRoZSBib3VuZGFyeSBjb25kaXRp b24gYXBwcm94aW1hdGlvbiB3aWxsDQo+Pj4+Pj4+PiBjb252ZXJnZQ0KPj4+Pj4+Pj4gaW4g dGhlIEwyIG5vcm0sIGJ1dCBpdCBjYW4ndCBjb252ZXJnZSBpbiBMX2luZmluaXR5Li4NCj4+ Pj4+Pg0KPj4+Pj4+IEkgZG9uJ3Qga25vdyB0aGUgZGV0YWlscywgc28gSSdtIG5vdCBzdXJl IGl0IG1ha2VzIHNlbnNlLCBidXQgaXQNCj4+Pj4+PiBsb29rcyB0byBtZSBsaWtlIHRoZSBw cmVzZW5jZSBhbmQgc2l6ZSBvZg0KPj4+Pj4+IG92ZXItdW5kZXJzaG9vdHMgZGVwZW5kcyBv biB0aGUgc2l6ZSBvZiB0aGUgY29hcnNlLWxldmVsIG1lc2guDQo+Pj4+Pj4gQ291bGQNCj4+ Pj4+PiB0aGlzIGJlIHJlbGF0ZWQgdG8gdGhlIHdheQ0KPj4+Pj4+IGhhbmdpbmcgbm9kZSBj b25zdHJhaW50cyBhcmUgaGFuZGxlZCAoTDIpPw0KPj4+Pj4+IEp1c3QgdG8gZ2V0IG1vcmUg aW5zaWdodDogd2lsbCBhIHVuaWZvcm1seSBBTVIgcmVmaW5lZCBtZXNoICANCj4+Pj4+PiBi ZWhhdmUNCj4+Pj4+PiBkaWZmZXJlbnRseSB0aGFuIGEgbm9uLXJlZmluZWQNCj4+Pj4+PiBt ZXNoIHdpdGggdGhlIHNhbWUgc2l6ZWQgZWxlbWVudHMgYXMgdGhlIGZpbmUgQU1SIG9uZXM/ IEhvdyAgDQo+Pj4+Pj4gbXVjaCBvZg0KPj4+Pj4+IGFuIGluZmx1ZW5jZSB3aWxsIHRoZSBj b2Fyc2UtbGV2ZWwNCj4+Pj4+PiBtZXNoIGhhdmU/DQo+Pj4+Pg0KPj4+Pj4gSXQgc2hvdWxk bid0IGRlcGVuZCBvbiB3aGF0IG1lc2ggeW91IHN0YXJ0IHdpdGgsIHVubGVzcyBpdCB3YXMN Cj4+Pj4+IGNvYXJzZQ0KPj4+Pj4gZW5vdWdoIHRvIGhhdmUgR2FsZXJraW4taW5zdGFiaWxp dHkgdHlwZSBvc2NpbGxhdGlvbnMuICBJbiB0aGF0DQo+Pj4+PiBjYXNlLA0KPj4+Pj4gbG9j YWwgY2VsbC1SZXlub2xkcyBudW1iZXIgdmlvbGF0aW9ucyBjYW4gY2F1c2Ugb3Zlci91bmRl cnNob290cw0KPj4+Pj4gKGZvcg0KPj4+Pj4gTmF2aWVyLVN0b2tlcyBvYnZpb3VzbHksIG5v dCBTdG9rZXMgZmxvdykuDQo+Pj4+Pg0KPj4+Pj4gSW4gYW5zd2VyIHRvIHlvdXIgc2Vjb25k IHF1ZXN0aW9uLCBhICJ1bmlmb3JtbHktcmVmaW5lZCBBTVIgbWVzaCINCj4+Pj4+IHNob3Vs ZCBiZWhhdmUgaWRlbnRpY2FsbHkgdG8gYSBub24tcmVmaW5lZCBtZXNoIHdpdGggdGhlIHNh bWUgc2l6ZQ0KPj4+Pj4gZWxlbWVudHMuICBJIHdvdWxkIGJlIGludGVyZXN0ZWQgaW4gc2Vl aW5nIGEgY2FzZSB3aGVyZSBpdCBkb2VzICANCj4+Pj4+IG5vdCwNCj4+Pj4+IGlmIHlvdSBo YXZlIG9uZS4NCj4+Pj4+DQo+Pj4+PiAtSg0KPj4+Pj4NCj4+Pj4+DQo+Pj4+Pg0KPj4+Pj4+ IFRoYW5rcyBhIGxvdCBmb3IgeW91ciB0aW1lDQo+Pj4+Pj4NCj4+Pj4+PiBMdWNhDQo+Pj4+ Pj4NCj4+Pj4+PiAtLQ0KPj4+Pj4+IEx1Y2EgQW50aWdhLCBQaEQNCj4+Pj4+PiBIZWFkLCBN ZWRpY2FsIEltYWdpbmcgVW5pdCwNCj4+Pj4+PiBCaW9lbmdpbmVlcmluZyBEZXBhcnRtZW50 LA0KPj4+Pj4+IE1hcmlvIE5lZ3JpIEluc3RpdHV0ZQ0KPj4+Pj4+IGVtYWlsOiBhbnRpZ2FA bWFyaW9uZWdyaS5pdA0KPj4+Pj4+IHdlYjogaHR0cDovL3ZpbGxhY2Ftb3p6aS5tYXJpb25l Z3JpLml0L35sdWNhDQo+Pj4+Pj4gbWFpbDogVmlsbGEgQ2Ftb3p6aSwgMjQwMjAsIFJhbmlj YSAoQkcpLCBJdGFseQ0KPj4+Pj4+IHBob25lOiArMzkgMDM1IDQ1MzUtMzgxDQo+Pj4+Pj4N Cj4+Pj4+Pg0KPj4+Pj4+IE9uIEFwciA0LCAyMDA3LCBhdCA0OjIyIFBNLCBKb2huIFBldGVy c29uIHdyb3RlOg0KPj4+Pj4+DQo+Pj4+Pj4+IFJveSBTdG9nbmVyIHdyaXRlczoNCj4+Pj4+ Pj4+IE9uIFdlZCwgNCBBcHIgMjAwNywgTHVjYSBBbnRpZ2Egd3JvdGU6DQo+Pj4+Pj4+Pg0K Pj4+Pj4+Pj4+IEkgY291bGQgbGl2ZSB3aXRoIG5vbiB6ZXJvIHZhbHVlcyBvbiB0aGUgemVy byB2ZWxvY2l0eSBmYWNlcywNCj4+Pj4+Pj4+PiBidXQNCj4+Pj4+Pj4+PiBhcmVuJ3QNCj4+ Pj4+Pj4+PiB0aG9zZSBhIGJpdCBsYXJnZSAoMTAlIG9mIHRoZSB0b3AgZmFjZSB2ZWxvY2l0 eSk/DQo+Pj4+Pj4+Pg0KPj4+Pj4+Pj4gWWVzLCBidXQgdGhlbiBHaWJicycgdHlwZSByaW5n aW5nIHVzdWFsbHkgaXMgbGFyZ2UuICBXaGF0J3MNCj4+Pj4+Pj4+IHdvcnNlOiBhcw0KPj4+ Pj4+Pj4geW91IHJlZmluZSB0aGUgbWVzaCB0aGUgYm91bmRhcnkgY29uZGl0aW9uIGFwcHJv eGltYXRpb24gd2lsbA0KPj4+Pj4+Pj4gY29udmVyZ2UNCj4+Pj4+Pj4+IGluIHRoZSBMMiBu b3JtLCBidXQgaXQgY2FuJ3QgY29udmVyZ2UgaW4gTF9pbmZpbml0eS4uDQo+Pj4+Pj4+Pg0K Pj4+Pj4+Pj4+IEknbSBqdXN0IHdvcnJpZWQgdGhhdCB0aGUgc2l0dWF0aW9uIG1pZ2h0IGdv IG91dCBvZiBjb250cm9sIGluDQo+Pj4+Pj4+Pj4gY29tcGxpY2F0ZWQgZ2VvbWV0cmllcywg c28gdGhhdCdzIHdoeSBJJ20gYSBiaXQgcGlja3kgb24gdGhpcw0KPj4+Pj4+Pj4+IHByb2Js ZW0uDQo+Pj4+Pj4+Pg0KPj4+Pj4+Pj4gSXQncyBub3QgdGhlIGdlb21ldHJ5IHRoYXQncyBj b250cm9sbGluZyB0aGUgcHJvYmxlbSwgaXQncyB0aGUNCj4+Pj4+Pj4+IGRpc2NvbnRpbnVp dHkgaW4gdGhlIGJvdW5kYXJ5IGNvbmRpdGlvbnMuDQo+Pj4+Pj4+DQo+Pj4+Pj4+PiBJIHRo aW5rIEpvaG4ncyBoYWQgc29tZXdoYXQgc21vb3RoZXIgcmVzdWx0cyBieSB1c2luZyBhbiBI MQ0KPj4+Pj4+Pj4gaW5zdGVhZA0KPj4+Pj4+Pj4gb2YgTDIgYm91bmRhcnkgcGVuYWx0eSwg YnV0IHdoZW4geW91IHRyeSB0byBmb3JjZSBhIGNvbnRpbnVvdXMNCj4+Pj4+Pj4+IGFwcHJv eGltYXRpb24gZnVuY3Rpb24gdG8gdGFrZSBvbiBkaXNjb250aW51b3VzIHZhbHVlcywgdGhl cmUncw0KPj4+Pj4+Pj4gcmVhbGx5IG5vIGdvb2Qgd2F5IGZvciBpdCB0byByZWFjdC4NCj4+ Pj4+Pj4NCj4+Pj4+Pj4gQWN0dWFsbHksIEkgY291bGRuJ3QgZ2V0IHRoZSBIMSBwcm9qZWN0 aW9uIHRvIHdvcmsgKGluIDJEKS4gIEkNCj4+Pj4+Pj4gdHJpZWQNCj4+Pj4+Pj4gcGVuYWxp emluZyB0aGUgdGFuZ2VudGlhbCBkZXJpdmF0aXZlcywgdG8gZS5nLiBlbmZvcmNlIGR1L2R4 PWR2Lw0KPj4+Pj4+PiBkeD0wDQo+Pj4+Pj4+IGFsb25nIHRoZSBsaWQuDQo+Pj4+Pj4+DQo+ Pj4+Pj4+IE9uZSB0aGluZyB0aGF0IHNlZW1lZCB0byBoZWxwIGEgYml0IChhdCBsZWFzdCBp biAyRCkgd2FzIHRvIHVzZQ0KPj4+Pj4+PiB0aGUNCj4+Pj4+Pj4gImx1bXBlZCIgTDIgcHJv amVjdGlvbiAoZS5nLiBleDEzKS4gIElmIG1lbW9yeSBzZXJ2ZXMsIHRoYXQNCj4+Pj4+Pj4g c29sdXRpb24NCj4+Pj4+Pj4gImxvb2tlZCIgc2xpZ2h0bHkgYmV0dGVyIChhdCBsZWFzdCBp biAyRCkuDQo+Pj4+Pj4+DQo+Pj4+Pj4+PiBNYW55IHBlb3BsZSBnaXZlIHVwIGFuZCBqdXN0 IHJlZ3VsYXJpemUgdGhlIHByb2JsZW0gYm91bmRhcnkNCj4+Pj4+Pj4+IGNvbmRpdGlvbnMu DQo+Pj4+Pj4+DQo+Pj4+Pj4+IEluZGVlZCwgdGhlIGh5cGVyYm9saWMgdGFuZ2VudC10eXBl IHJlZ3VsYXJpemVkIGJvdW5kYXJ5DQo+Pj4+Pj4+IGNvbmRpdGlvbnMNCj4+Pj4+Pj4gc2Vl bSB0byBiZQ0KPj4+Pj4+PiBmYWlybHkgc3RhbmRhcmQgaW4gdGhlIGxpdGVyYXR1cmUgZm9y IHRoaXMgdHlwZSBvZiBwcm9ibGVtLiAgIA0KPj4+Pj4+PiBJZiB3ZQ0KPj4+Pj4+PiBqdXN0 DQo+Pj4+Pj4+IHdhbnQgdG8gYmUgc3VyZSBTdG9rZXMrQU1SK1RldHMgaXMgd29ya2luZywg bGV0J3MgdHJ5IGEgdGVzdA0KPj4+Pj4+PiBwcm9ibGVtDQo+Pj4+Pj4+IHdpdGggY29udGlu dW91cyBkYXRhPw0KPj4+Pj4+Pg0KPj4+Pj4+PiAtSg0KDQoNCg0KDQotLS0NCkRlc3RpbmEg aWwgdHVvIDUgcGVyIG1pbGxlIGRlbGwnSVJQRUYgIChzdWwgbW9kLiA3MzAgbyBtb2QuIFVO SUNPIG8NCm1vZC4gQ1VEKSBmaXJtYW5kbyBlIGluZGljYW5kbyBpbCBub3N0cm8gY29kaWNl IGZpc2NhbGUgMDMyNTQyMTAxNTANCm5lbCByaXF1YWRybyAgICJmaW5hbnppYW1lbnRvIGFn bGkgZW50aSBkZWxsYSByaWNlcmNhIHNjaWVudGlmaWNhIGUNCmRlbGwndW5pdmVyc2l0YSci ICAgcGVyIGFpdXRhcmUgYSBtYW50ZW5lcmUgaW5kaXBlbmRlbnRlIGxhIHJpY2VyY2ENCnNj aWVudGlmaWNhIGRlbGwnSXN0aXR1dG8gTWFyaW8gTmVncmksIHVuYSBmb25kYXppb25lIHBy aXZhdGEgc2VuemENCnNjb3BvIGRpIGx1Y3JvIGNoZSBkYSBvbHRyZSA0MCBhbm5pIG9wZXJh IG5lbGwnaW50ZXJlc3NlIGRlZ2xpDQphbW1hbGF0aS4NCg0KUGVyIG1hZ2dpb3JpIGluZm9y bWF6aW9uaToNCklzdGl0dXRvIE1hcmlvIE5lZ3JpLCBWaWEgRXJpdHJlYSA2MiAtIDIwMTU3 IE1pbGFubw0KVGVsOiArMzkgMDIgMzkwMTQzMTcgLSBGYXg6ICszOSAwMiAzNTQ2Mjc3ICsz OSAwMiAzOTAwMTkxOA0KSW50ZXJuZXQ6IHd3dy5tYXJpb25lZ3JpLml0LCBtbmVncmlAbWFy aW9uZWdyaS5pdA== ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-12 07:46 ```Um95LCBKb2huLA0KICBJIGFncmVlIHdpdGggUm95IG9uIHRoaXMgb25lLiBXZSBkbyBoYXZl IGEgcmVwcm9kdWNpYmxlIGNhc2UsIGJ1dCAgDQppdCdzIGJhc2VkIG9uIGEgcHJldHR5DQpi aWcgbWVzaCBvZiBhIHJlYWwgdmVzc2VsLiBXZSdyZSB0cnlpbmcgdG8gZmluZCBhIHNtYWxs ZXIgY2FzZSB0byAgDQpwb3N0IG9uIG91ciB3ZWIgcGFnZQ0KYWxvbmcgd2l0aCB0aGUgY29k ZS4NClRoYW5rcyBmb3IgdGhlIGhlbHANCg0KTHVjYQ0KDQotLQ0KTHVjYSBBbnRpZ2EsIFBo RA0KSGVhZCwgTWVkaWNhbCBJbWFnaW5nIFVuaXQsDQpCaW9lbmdpbmVlcmluZyBEZXBhcnRt ZW50LA0KTWFyaW8gTmVncmkgSW5zdGl0dXRlDQplbWFpbDogYW50aWdhQG1hcmlvbmVncmku aXQNCndlYjogaHR0cDovL3ZpbGxhY2Ftb3p6aS5tYXJpb25lZ3JpLml0L35sdWNhDQptYWls OiBWaWxsYSBDYW1venppLCAyNDAyMCwgUmFuaWNhIChCRyksIEl0YWx5DQpwaG9uZTogKzM5 IDAzNSA0NTM1LTM4MQ0KDQoNCk9uIEFwciAxMSwgMjAwNywgYXQgNjozNiBQTSwgUm95IFN0 b2duZXIgd3JvdGU6DQoNCj4gT24gV2VkLCAxMSBBcHIgMjAwNywgSm9obiBQZXRlcnNvbiB3 cm90ZToNCj4NCj4+IFRoaXMgYXBwYXJlbnQgMi1sZXZlbCByZWZpbmVtZW50IG1heSBiZSBk dWUgdG8gdGhlIGZhY3QgdGhhdCB3ZSBwbG90DQo+PiAxMC1ub2RlIFRldHMgYXMgOCBsaW5l YXIgdGV0cmFoZWRyYSBpbiBHTVYuICBTbyBmb3IgZXhhbXBsZSBpbiB0aGUNCj4+IGZpZ3Vy ZXMgb24geW91ciB3ZWJwYWdlIGl0IGxvb2tzIGxpa2UgbGV2ZWwtMSBpcyBlbmZvcmNlZC4N Cj4NCj4gSSBkb24ndCB0aGluayBvdXIgcGxvdHRpbmcgZGVjaW1hdGlvbiBzaG91bGQgZXZl ciBnaXZlIGFueXRoaW5nIHRoYXQNCj4gbG9va3MgbGlrZSBhIGxldmVsLTIgaGFuZ2luZyBu b2RlIG9uIGEgbGV2ZWwtMSBtZXNoLg0KPg0KPiBMZXQgdXMga25vdyBpZiB5b3UgZXZlciBk byBzZWUgc3VjaCBhIHRoaW5nLCBlc3BlY2lhbGx5IGlmIHlvdSBjYW4NCj4gY29kZSB1cCBh IHJlcGVhdGFibGUgZXhhbXBsZSBvZiBpdC4gIEkgdGhpbmsgSSByZWZhY3RvcmVkIHRoZSBo DQo+IHJlZmluZW1lbnQgY29kZSBhIGJpdCB3aGlsZSBJIHdhcyBhZGRpbmcgcCByZWZpbmVt ZW50IGxhc3QgeWVhciwgYW5kDQo+IGFsdGhvdWdoIGJ5IG5vdyB0aGUgcmVzdWx0IGlzIHBy ZXR0eSB3ZWxsLXRlc3RlZCBvbiB0cmlhbmdsZXMsIHF1YWRzLA0KPiBhbmQgY3ViZXMgSSB3 b3VsZG4ndCB3YW50IHRvIGd1YXJhbnRlZSB0aGF0IEkgZGlkbid0IGludHJvZHVjZSBzb21l DQo+IHN1YnRsZSB0ZXQtc3BlY2lmaWMgYnVnLg0KPiAtLS0NCj4gUm95DQoNCg0KDQoNCi0t LQ0KRGVzdGluYSBpbCB0dW8gNSBwZXIgbWlsbGUgZGVsbCdJUlBFRiAgKHN1bCBtb2QuIDcz MCBvIG1vZC4gVU5JQ08gbw0KbW9kLiBDVUQpIGZpcm1hbmRvIGUgaW5kaWNhbmRvIGlsIG5v c3RybyBjb2RpY2UgZmlzY2FsZSAwMzI1NDIxMDE1MA0KbmVsIHJpcXVhZHJvICAgImZpbmFu emlhbWVudG8gYWdsaSBlbnRpIGRlbGxhIHJpY2VyY2Egc2NpZW50aWZpY2EgZQ0KZGVsbCd1 bml2ZXJzaXRhJyIgICBwZXIgYWl1dGFyZSBhIG1hbnRlbmVyZSBpbmRpcGVuZGVudGUgbGEg cmljZXJjYQ0Kc2NpZW50aWZpY2EgZGVsbCdJc3RpdHV0byBNYXJpbyBOZWdyaSwgdW5hIGZv bmRhemlvbmUgcHJpdmF0YSBzZW56YQ0Kc2NvcG8gZGkgbHVjcm8gY2hlIGRhIG9sdHJlIDQw IGFubmkgb3BlcmEgbmVsbCdpbnRlcmVzc2UgZGVnbGkNCmFtbWFsYXRpLg0KDQpQZXIgbWFn Z2lvcmkgaW5mb3JtYXppb25pOg0KSXN0aXR1dG8gTWFyaW8gTmVncmksIFZpYSBFcml0cmVh IDYyIC0gMjAxNTcgTWlsYW5vDQpUZWw6ICszOSAwMiAzOTAxNDMxNyAtIEZheDogKzM5IDAy IDM1NDYyNzcgKzM5IDAyIDM5MDAxOTE4DQpJbnRlcm5ldDogd3d3Lm1hcmlvbmVncmkuaXQs IG1uZWdyaUBtYXJpb25lZ3JpLml0 ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-04-12 17:19 ```On Thu, 12 Apr 2007, Luca Antiga wrote: > Hey John, > >> This hanging node is constrained to take on 1/2 the x-velocity value >> of the lid (1.0) and the side wall (0.0). So it obtains a value of >> roughly 1/2. I think this is correct from the standpoint that this >> is what the library implements, but whether or not it is correct >> in the sense of "this is what you want to see" is debatable. In your >> refined hex mesh there is no such coarse element sitting on the boundary, >> so you don't see this effect there. > > I see the point now. Thanks for the explanation. Lorenzo found a set > of refinement parameters that prevents this with tets too. If no > hanging nodes sit on edges connected to the top boundary, no > spurious velocities are generated. Makes sense. I think it depends on what you mean by spurious velocities. These are finite elements we're working with, after all - just because there isn't a grid node at point x doesn't mean there isn't a velocity defined there. And, because they're C^0 finite elements, that velocity will always be either less than one somewhere on the top boundary, greater than zero somewhere on the side boundary, or both. You can try to hide that in your plotting software but you can't get around it without using a different approximation function space. If this is really bothering you, you could try one idea I've toyed with: use a partially discontinuous scheme. Instead of generating a standard square/cube mesh, generate a mesh with a "slit" at the discontinuities along the top boundary. You can then use a Dirichlet velocity boundary condition which is exactly 1 over the entire top, exactly 0 over the entire sides, and which includes a discontinuous Galerkin term on the slit to maintain consistency. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: Luca Antiga - 2007-04-13 15:04 ```PiBJIHRoaW5rIGl0IGRlcGVuZHMgb24gd2hhdCB5b3UgbWVhbiBieSBzcHVyaW91cyB2ZWxv Y2l0aWVzLiAgVGhlc2UgYXJlDQo+IGZpbml0ZSBlbGVtZW50cyB3ZSdyZSB3b3JraW5nIHdp dGgsIGFmdGVyIGFsbCAtIGp1c3QgYmVjYXVzZSB0aGVyZQ0KPiBpc24ndCBhIGdyaWQgbm9k ZSBhdCBwb2ludCB4IGRvZXNuJ3QgbWVhbiB0aGVyZSBpc24ndCBhIHZlbG9jaXR5DQo+IGRl ZmluZWQgdGhlcmUuICBBbmQsIGJlY2F1c2UgdGhleSdyZSBDXjAgZmluaXRlIGVsZW1lbnRz LCB0aGF0DQo+IHZlbG9jaXR5IHdpbGwgYWx3YXlzIGJlIGVpdGhlciBsZXNzIHRoYW4gb25l IHNvbWV3aGVyZSBvbiB0aGUgdG9wDQo+IGJvdW5kYXJ5LCBncmVhdGVyIHRoYW4gemVybyBz b21ld2hlcmUgb24gdGhlIHNpZGUgYm91bmRhcnksIG9yIGJvdGguDQo+IFlvdSBjYW4gdHJ5 IHRvIGhpZGUgdGhhdCBpbiB5b3VyIHBsb3R0aW5nIHNvZnR3YXJlIGJ1dCB5b3UgY2FuJ3Qg Z2V0DQo+IGFyb3VuZCBpdCB3aXRob3V0IHVzaW5nIGEgZGlmZmVyZW50IGFwcHJveGltYXRp b24gZnVuY3Rpb24gc3BhY2UuDQoNCkkgYWJzb2x1dGVseSBhZ3JlZSwgSSBpbmNvcnJlY3Rs eSB1c2VkIHRoZSB0ZXJtICJzcHVyaW91cyIuDQoNCj4gSWYgdGhpcyBpcyByZWFsbHkgYm90 aGVyaW5nIHlvdSwgeW91IGNvdWxkIHRyeSBvbmUgaWRlYSBJJ3ZlIHRveWVkDQo+IHdpdGg6 IHVzZSBhIHBhcnRpYWxseSBkaXNjb250aW51b3VzIHNjaGVtZS4gIEluc3RlYWQgb2YgZ2Vu ZXJhdGluZyBhDQo+IHN0YW5kYXJkIHNxdWFyZS9jdWJlIG1lc2gsIGdlbmVyYXRlIGEgbWVz aCB3aXRoIGEgInNsaXQiIGF0IHRoZQ0KPiBkaXNjb250aW51aXRpZXMgYWxvbmcgdGhlIHRv cCBib3VuZGFyeS4gIFlvdSBjYW4gdGhlbiB1c2UgYSBEaXJpY2hsZXQNCj4gdmVsb2NpdHkg Ym91bmRhcnkgY29uZGl0aW9uIHdoaWNoIGlzIGV4YWN0bHkgMSBvdmVyIHRoZSBlbnRpcmUg dG9wLA0KPiBleGFjdGx5IDAgb3ZlciB0aGUgZW50aXJlIHNpZGVzLCBhbmQgd2hpY2ggaW5j bHVkZXMgYSBkaXNjb250aW51b3VzDQo+IEdhbGVya2luIHRlcm0gb24gdGhlIHNsaXQgdG8g bWFpbnRhaW4gY29uc2lzdGVuY3kuDQoNClRoYXQncyBhIG5lYXQgaWRlYSwgd2UnbGwgY29u c2lkZXIgdGhpcyBpbiBjYXNlIHdlIGZhY2UgYSBwcmFjdGljYWwgIA0KcHJvYmxlbQ0Kd2l0 aCBhIGRpc2NvbnRpbnVpdHkgaW4gdGhlIGJvdW5kYXJ5IGNvbmRpdGlvbnMuIEZvciB0aGUg bW9tZW50IHdlJ3JlDQpjb25jZW50cmF0aW5nIG9uIHRoZSB2ZXNzZWwgY2FzZSwgd2hpY2gg ZG9lc24ndCBwb3NlIHRoaXMgcHJvYmxlbS4NCg0KVGhhbmtzIQ0KDQpMdWNhDQoNCi0tDQpM dWNhIEFudGlnYSwgUGhEDQpIZWFkLCBNZWRpY2FsIEltYWdpbmcgVW5pdCwNCkJpb2VuZ2lu ZWVyaW5nIERlcGFydG1lbnQsDQpNYXJpbyBOZWdyaSBJbnN0aXR1dGUNCmVtYWlsOiBhbnRp Z2FAbWFyaW9uZWdyaS5pdA0Kd2ViOiBodHRwOi8vdmlsbGFjYW1venppLm1hcmlvbmVncmku aXQvfmx1Y2ENCm1haWw6IFZpbGxhIENhbW96emksIDI0MDIwLCBSYW5pY2EgKEJHKSwgSXRh bHkNCnBob25lOiArMzkgMDM1IDQ1MzUtMzgxDQoNCg0KT24gQXByIDEyLCAyMDA3LCBhdCA3 OjE5IFBNLCBSb3kgU3RvZ25lciB3cm90ZToNCg0KPiBPbiBUaHUsIDEyIEFwciAyMDA3LCBM dWNhIEFudGlnYSB3cm90ZToNCj4NCj4+IEhleSBKb2huLA0KPj4NCj4+PiBUaGlzIGhhbmdp bmcgbm9kZSBpcyBjb25zdHJhaW5lZCB0byB0YWtlIG9uIDEvMiB0aGUgeC12ZWxvY2l0eSB2 YWx1ZQ0KPj4+IG9mIHRoZSBsaWQgKDEuMCkgYW5kIHRoZSBzaWRlIHdhbGwgKDAuMCkuICBT byBpdCBvYnRhaW5zIGEgdmFsdWUgb2YNCj4+PiByb3VnaGx5IDEvMi4gIEkgdGhpbmsgdGhp cyBpcyBjb3JyZWN0IGZyb20gdGhlIHN0YW5kcG9pbnQgdGhhdCB0aGlzDQo+Pj4gaXMgd2hh dCB0aGUgbGlicmFyeSBpbXBsZW1lbnRzLCBidXQgd2hldGhlciBvciBub3QgaXQgaXMgY29y cmVjdA0KPj4+IGluIHRoZSBzZW5zZSBvZiAidGhpcyBpcyB3aGF0IHlvdSB3YW50IHRvIHNl ZSIgaXMgZGViYXRhYmxlLiAgSW4gIA0KPj4+IHlvdXINCj4+PiByZWZpbmVkIGhleCBtZXNo IHRoZXJlIGlzIG5vIHN1Y2ggY29hcnNlIGVsZW1lbnQgc2l0dGluZyBvbiB0aGUgIA0KPj4+ IGJvdW5kYXJ5LA0KPj4+IHNvIHlvdSBkb24ndCBzZWUgdGhpcyBlZmZlY3QgdGhlcmUuDQo+ Pg0KPj4gSSBzZWUgdGhlIHBvaW50IG5vdy4gVGhhbmtzIGZvciB0aGUgZXhwbGFuYXRpb24u IExvcmVuem8gZm91bmQgYSBzZXQNCj4+IG9mIHJlZmluZW1lbnQgcGFyYW1ldGVycyB0aGF0 IHByZXZlbnRzIHRoaXMgd2l0aCB0ZXRzIHRvby4gSWYgbm8NCj4+IGhhbmdpbmcgbm9kZXMg c2l0IG9uIGVkZ2VzIGNvbm5lY3RlZCB0byB0aGUgdG9wIGJvdW5kYXJ5LCBubw0KPj4gc3B1 cmlvdXMgdmVsb2NpdGllcyBhcmUgZ2VuZXJhdGVkLiBNYWtlcyBzZW5zZS4NCj4NCj4gSSB0 aGluayBpdCBkZXBlbmRzIG9uIHdoYXQgeW91IG1lYW4gYnkgc3B1cmlvdXMgdmVsb2NpdGll cy4gIFRoZXNlIGFyZQ0KPiBmaW5pdGUgZWxlbWVudHMgd2UncmUgd29ya2luZyB3aXRoLCBh ZnRlciBhbGwgLSBqdXN0IGJlY2F1c2UgdGhlcmUNCj4gaXNuJ3QgYSBncmlkIG5vZGUgYXQg cG9pbnQgeCBkb2Vzbid0IG1lYW4gdGhlcmUgaXNuJ3QgYSB2ZWxvY2l0eQ0KPiBkZWZpbmVk IHRoZXJlLiAgQW5kLCBiZWNhdXNlIHRoZXkncmUgQ14wIGZpbml0ZSBlbGVtZW50cywgdGhh dA0KPiB2ZWxvY2l0eSB3aWxsIGFsd2F5cyBiZSBlaXRoZXIgbGVzcyB0aGFuIG9uZSBzb21l d2hlcmUgb24gdGhlIHRvcA0KPiBib3VuZGFyeSwgZ3JlYXRlciB0aGFuIHplcm8gc29tZXdo ZXJlIG9uIHRoZSBzaWRlIGJvdW5kYXJ5LCBvciBib3RoLg0KPiBZb3UgY2FuIHRyeSB0byBo aWRlIHRoYXQgaW4geW91ciBwbG90dGluZyBzb2Z0d2FyZSBidXQgeW91IGNhbid0IGdldA0K PiBhcm91bmQgaXQgd2l0aG91dCB1c2luZyBhIGRpZmZlcmVudCBhcHByb3hpbWF0aW9uIGZ1 bmN0aW9uIHNwYWNlLg0KPg0KPiBJZiB0aGlzIGlzIHJlYWxseSBib3RoZXJpbmcgeW91LCB5 b3UgY291bGQgdHJ5IG9uZSBpZGVhIEkndmUgdG95ZWQNCj4gd2l0aDogdXNlIGEgcGFydGlh bGx5IGRpc2NvbnRpbnVvdXMgc2NoZW1lLiAgSW5zdGVhZCBvZiBnZW5lcmF0aW5nIGENCj4g c3RhbmRhcmQgc3F1YXJlL2N1YmUgbWVzaCwgZ2VuZXJhdGUgYSBtZXNoIHdpdGggYSAic2xp dCIgYXQgdGhlDQo+IGRpc2NvbnRpbnVpdGllcyBhbG9uZyB0aGUgdG9wIGJvdW5kYXJ5LiAg WW91IGNhbiB0aGVuIHVzZSBhIERpcmljaGxldA0KPiB2ZWxvY2l0eSBib3VuZGFyeSBjb25k aXRpb24gd2hpY2ggaXMgZXhhY3RseSAxIG92ZXIgdGhlIGVudGlyZSB0b3AsDQo+IGV4YWN0 bHkgMCBvdmVyIHRoZSBlbnRpcmUgc2lkZXMsIGFuZCB3aGljaCBpbmNsdWRlcyBhIGRpc2Nv bnRpbnVvdXMNCj4gR2FsZXJraW4gdGVybSBvbiB0aGUgc2xpdCB0byBtYWludGFpbiBjb25z aXN0ZW5jeS4NCj4gLS0tDQo+IFJveQ0KDQoNCg0KDQotLS0NCkRlc3RpbmEgaWwgdHVvIDUg cGVyIG1pbGxlIGRlbGwnSVJQRUYgIChzdWwgbW9kLiA3MzAgbyBtb2QuIFVOSUNPIG8NCm1v ZC4gQ1VEKSBmaXJtYW5kbyBlIGluZGljYW5kbyBpbCBub3N0cm8gY29kaWNlIGZpc2NhbGUg MDMyNTQyMTAxNTANCm5lbCByaXF1YWRybyAgICJmaW5hbnppYW1lbnRvIGFnbGkgZW50aSBk ZWxsYSByaWNlcmNhIHNjaWVudGlmaWNhIGUNCmRlbGwndW5pdmVyc2l0YSciICAgcGVyIGFp dXRhcmUgYSBtYW50ZW5lcmUgaW5kaXBlbmRlbnRlIGxhIHJpY2VyY2ENCnNjaWVudGlmaWNh IGRlbGwnSXN0aXR1dG8gTWFyaW8gTmVncmksIHVuYSBmb25kYXppb25lIHByaXZhdGEgc2Vu emENCnNjb3BvIGRpIGx1Y3JvIGNoZSBkYSBvbHRyZSA0MCBhbm5pIG9wZXJhIG5lbGwnaW50 ZXJlc3NlIGRlZ2xpDQphbW1hbGF0aS4NCg0KUGVyIG1hZ2dpb3JpIGluZm9ybWF6aW9uaToN CklzdGl0dXRvIE1hcmlvIE5lZ3JpLCBWaWEgRXJpdHJlYSA2MiAtIDIwMTU3IE1pbGFubw0K VGVsOiArMzkgMDIgMzkwMTQzMTcgLSBGYXg6ICszOSAwMiAzNTQ2Mjc3ICszOSAwMiAzOTAw MTkxOA0KSW50ZXJuZXQ6IHd3dy5tYXJpb25lZ3JpLml0LCBtbmVncmlAbWFyaW9uZWdyaS5p dA== ```

 [Libmesh-users] AMR in 3D From: Lorenzo Botti - 2007-05-03 10:47 Attachments: Message as HTML ```Hy all, sorry for the lag since our last posts... We have good news! You remember we are working on a Navier-Stokes solver and we encountered some problems with AMR dealing with 3D tet meshes . Once we understood (thanks for the help!) problems related with the lid driven cavity (hanging nodes + discontinuos boundary conditions) we moved to 3D tet meshes of real vessels. In this case, we noticed spurious large velocity vectors arising randomly from AMR refined regions, which eventually caused the solution to blow up. We thought that this may be caused by the fact that level one condition was broken, but, analyzing the mesh more accurately, we found that level one condition was always satisfied. Instead, it looks like the problem is level one condition at nodes. The problem can be fixed uncommenting (see code below) the call to the function bool MeshRefinement::limit_level_mismatch_at_node(const int max_level_mismatch) at line 519 of bool MeshRefinement::refine_elements(const bool maintain_level_one = true). 00512 while (!satisfied) 00513 { 00514 const bool refinement_satisfied = 00515 this->make_refinement_compatible (maintain_level_one); 00516 00517 const bool smoothing_satisfied = 00518 !this->eliminate_unrefined_patches ();// && 00519 // !this->limit_level_mismatch_at_node(1); 00520 00521 satisfied = (refinement_satisfied && 00522 smoothing_satisfied); 00523 } We think that with Hex this function may have a little impact on the solution but with Tet it is really important. In fact, with level one compatibility on elements, elements may have a two level node mismatch with neighbors sharing just an edge (not a whole face). For Hexes the problem is limited to "diagonal" neighbors, while for Tets probably level mismatch is more frequent, since many tets in general share the same edge. Whatever it is, enforcing level one on nodes solved the problem of spurious velocity vectors. Do you have any idea on what's going on? Thanks again Lorenzo ```

 [Libmesh-users] AMR in 3D From: John Peterson - 2007-05-03 14:18 ```Hi, I'm glad you found that this works, but I wonder if it means there is a problem with the way we are constraining hanging "face" nodes on Tet10's, and this fix is just masking the bigger problem. I have some questions... .) Were the spurious velocities coming particularly from the non-level-1 constrained nodes? Or were they arising from hanging (edge or face) nodes? .) (Curiosity) How many more elements does flagging based on level-1 at the nodes introduce vs. not maintaining level-1 at the nodes? It seems that your mesh size would blow up quickly doing this. -John Lorenzo Botti writes: > Hy all, > sorry for the lag since our last posts... > > We have good news! > You remember we are working on a Navier-Stokes solver and we encountered > some problems with AMR dealing with 3D tet meshes . > Once we understood (thanks for the help!) problems related with the lid > driven cavity (hanging nodes + discontinuos boundary conditions) we > moved to 3D tet meshes of real vessels. > In this case, we noticed spurious large velocity vectors arising randomly > from AMR refined regions, which eventually caused the solution to blow up. > We thought that this may be caused by the fact that level one condition was > broken, but, analyzing the mesh more accurately, we found that level one > condition was always satisfied. > Instead, it looks like the problem is level one condition at nodes. > > The problem can be fixed uncommenting (see code below) the call to the > function > bool MeshRefinement::limit_level_mismatch_at_node(const int > max_level_mismatch) at line 519 of bool > MeshRefinement::refine_elements(const bool maintain_level_one = true). > > 00512 while (!satisfied) > > 00513 { > > 00514 const bool refinement_satisfied = > > 00515 this->make_refinement_compatible > (maintain_level_one); > > 00516 > > 00517 const bool smoothing_satisfied = > > 00518 !this->eliminate_unrefined_patches > ();// > && > 00519 // !this->limit_level_mismatch_at_node(1); > 00520 > > 00521 satisfied = (refinement_satisfied && > > 00522 smoothing_satisfied); > > 00523 } > > > We think that with Hex this function may have a little impact on the > solution but with Tet it is really important. In fact, with level one > compatibility on elements, elements may have a two level node mismatch with > neighbors sharing just an edge (not a whole face). For Hexes the problem is > limited to "diagonal" neighbors, while for Tets probably level mismatch is > more frequent, since many tets in general share the same edge. Whatever it > is, enforcing level one on nodes solved the problem of spurious velocity > vectors. > Do you have any idea on what's going on? > > Thanks again > Lorenzo ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-05-03 14:40 ```On Thu, 3 May 2007, John Peterson wrote: > I'm glad you found that this works, but I wonder if it means there is > a problem with the way we are constraining hanging "face" nodes on > Tet10's, and this fix is just masking the bigger problem. It sounds like there's two possible problems on tets here. Either: 1. Our hanging nodes aren't producing conforming function spaces. Or: 2. The function spaces you get by only enforcing level-one restrictions on faces aren't well-suited for Navier-Stokes. Possibility 1 should be easy enough to test - run a DiscontinuityMeasure over your solutions and make sure the amount discontinuity it sees is on the order of floating point error. For possibility 2, we might want to make "maintain_nodal_level_one" an option along with "maintain_level_one". I don't want to make the former behavior standard, since it would be a backwards-incompatible behavior change and it might be too expensive for many users. However making it an option would be a good idea. I'm thinking we deprecate the maintain_level_one method argument and then make both options into private MeshRefinement variables with accessor methods, like refine_fraction and such. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-05-03 14:56 ```Roy Stogner writes: > On Thu, 3 May 2007, John Peterson wrote: > > > I'm glad you found that this works, but I wonder if it means there is > > a problem with the way we are constraining hanging "face" nodes on > > Tet10's, and this fix is just masking the bigger problem. > > It sounds like there's two possible problems on tets here. Either: > > 1. Our hanging nodes aren't producing conforming function spaces. > > Or: > > 2. The function spaces you get by only enforcing level-one > restrictions on faces aren't well-suited for Navier-Stokes. > > Possibility 1 should be easy enough to test - run a > DiscontinuityMeasure over your solutions and make sure the > amount discontinuity it sees is on the order of floating point error. > > For possibility 2, we might want to make "maintain_nodal_level_one" an > option along with "maintain_level_one". I don't want to make the > former behavior standard, since it would be a backwards-incompatible > behavior change and it might be too expensive for many users. However > making it an option would be a good idea. I'm thinking we deprecate > the maintain_level_one method argument and then make both options into > private MeshRefinement variables with accessor methods, like > refine_fraction and such. This is a good solution in the meantime, IMO. I'd still like to know what's going on with Navier-Stokes ... including why this doesn't show up (so far) on hexes. It seems that just having "fewer" greater-than-level-1 mismatched nodes in Hex meshes wouldn't be enough to prevent the problem, i.e. *any* greater-than-level-1 mismatched nodes should seemingly trigger it. I never got around to setting up a smooth (with smooth BCs) 3D Stokes/Navier-Stokes test problem. It seems that would be an important first step in testing your hypotheses above. If anyone has a suggestion I'd be happy to try it... -J ```

 Re: [Libmesh-users] AMR in 3D From: Lorenzo Botti - 2007-05-03 15:38 Attachments: Message as HTML ```>.) Were the spurious velocities coming particularly from the > non-level-1 constrained nodes? Or were they arising from hanging > (edge or face) nodes? It's hard to tell right away... It seems that the problem involves a small region surrounding a non level-one edge, but it's tricky to tell for sure just using gmv. The point is that the problem doesn't seem to be systematic. What I can tell is that there are non-level-1 constrained nodes that don't involve spurious velocity vectors, but without limiting nodal level mismatch we always find a region were the solution blows up. I'll investigate this and I'll send you some screenshots... >.) (Curiosity) How many more elements does flagging based on level-1 > at the nodes introduce vs. not maintaining level-1 at the nodes? > It seems that your mesh size would blow up quickly doing this. Not so quickly but actually with my 2Gb of ram i can't go further 80000 elements in my simulations (using GMRES/ILU with a restart of 400). The resulting refined mesh is much more uniform than without level-1-mismatch control, with an increase of 10000/15000 elements over 80000. > Possibility 1 should be easy enough to test - run a > DiscontinuityMeasure over your solutions and make sure the > amount discontinuity it sees is on the order of floating point error. I'll try this... Thanks a lot for your help. Lorenzo 2007/5/3, John Peterson : > > Roy Stogner writes: > > On Thu, 3 May 2007, John Peterson wrote: > > > > > I'm glad you found that this works, but I wonder if it means there is > > > a problem with the way we are constraining hanging "face" nodes on > > > Tet10's, and this fix is just masking the bigger problem. > > > > It sounds like there's two possible problems on tets here. Either: > > > > 1. Our hanging nodes aren't producing conforming function spaces. > > > > Or: > > > > 2. The function spaces you get by only enforcing level-one > > restrictions on faces aren't well-suited for Navier-Stokes. > > > > Possibility 1 should be easy enough to test - run a > > DiscontinuityMeasure over your solutions and make sure the > > amount discontinuity it sees is on the order of floating point error. > > > > For possibility 2, we might want to make "maintain_nodal_level_one" an > > option along with "maintain_level_one". I don't want to make the > > former behavior standard, since it would be a backwards-incompatible > > behavior change and it might be too expensive for many users. However > > making it an option would be a good idea. I'm thinking we deprecate > > the maintain_level_one method argument and then make both options into > > private MeshRefinement variables with accessor methods, like > > refine_fraction and such. > > This is a good solution in the meantime, IMO. I'd still like to know > what's going on with Navier-Stokes ... including why this doesn't show > up (so far) on hexes. It seems that just having "fewer" > greater-than-level-1 mismatched nodes in Hex meshes wouldn't be enough > to prevent the problem, i.e. *any* greater-than-level-1 mismatched > nodes should seemingly trigger it. > > I never got around to setting up a smooth (with smooth BCs) 3D > Stokes/Navier-Stokes test problem. It seems that would be an important > first step in testing your hypotheses above. If anyone has a suggestion > I'd be happy to try it... > > -J > ```

 Re: [Libmesh-users] AMR in 3D From: John Peterson - 2007-05-04 17:33 ```Hi, I've done some numerical experiments with 3D Navier-Stokes and hanging edges. I'm using prisms since they are simpler to visualize. Here's the test mesh used: http://www.cfdlab.ae.utexas.edu/~peterson/hanging_prisms_full_domain.png The boundary condition is a C1-continuous lid velocity which decays to zero at the edge. This avoids pressure singularities and discontinuous boundary conditions. The edges in the center of the box have a level-2 mismatch even though level-1 face mismatch is enforced throughout. On coarse grids, I initially noticed some slightly higher velocities along the level-2 mismatched edge. Here's a y-cutplane of u: http://www.cfdlab.ae.utexas.edu/~peterson/hanging_prisms_u.png We can't really interpret this too closely, since these are quadratic elements plotted as linears. Under uniform refinement, this region of lower-than-average velocity is not present. http://www.cfdlab.ae.utexas.edu/~peterson/hanging_prisms_x2_u.png To get some idea of the relative sizes of the discontinuity, I also plotted as a surface here (again, quadratics plotted as 4 linears!): http://www.cfdlab.ae.utexas.edu/~peterson/discontinuous_u_surface.png Obviously, there aren't any problems when u=const across the interface. The (potentially) more interesting thing appears to be the linear/nonlinear solver convergence when such a mismatched edge is present. Here, I present the relative and absolute Newton step sizes, and the nonlinear and linear system residuals for the first timestep of the once uniformly-refined version of the mesh with the level-2 mismatch hanging edge: |du|/|u| |du| nonlinear |R| linear |R| 1 114.377 2.32242e+08 7.74163e-11 0.376716 41.3106 0.000908376 7.27909e-12 0.236782 27.9334 3.08814e-05 4.52935e-13 0.0958868 11.8114 7.95717e-06 6.28991e-14 0.040872 5.13872 3.45092e-06 2.43645e-14 0.0176168 2.23529 1.50099e-06 1.30614e-14 0.0076324 0.972337 6.52953e-07 5.33396e-15 0.0033142 0.422959 2.841e-07 2.29361e-15 0.00144055 0.183984 1.23752e-07 9.92329e-16 5.40359e-08 4.30634e-16 The poor convergence of Newton does not appear to be due to insufficient solution of the linear subproblems. This is the first timestep, so it is the hardest solve. Timesteps nearer steady state start with smaller initial residuals but still converge poorly. For comparison, I also ran the problem with the opposing central prisms also refined: http://www.cfdlab.ae.utexas.edu/~peterson/matched_prisms_x.png In this case, the convergence of the solver during the first timestep is much better |du|/|u| |du| nonlinear |R| linear |R| 1 158.132 1.54155e+08 8.68055e-11 0.171657 26.5923 0.000375404 6.72722e-12 0.00567181 0.878692 9.36429e-06 3.1895e-13 6.53108e-09 2.82395e-16 So while I don't find any evidence of spurious velocities "blowing up" and trashing the solution, I do think it is highly possible that the level-2 mismatched edge is causing Newton to fail to converge, possibly due to ill-conditioning of the linear systems (?) -John Lorenzo Botti writes: > >.) Were the spurious velocities coming particularly from the > > non-level-1 constrained nodes? Or were they arising from hanging > > (edge or face) nodes? > > It's hard to tell right away... It seems that the problem involves a small > region surrounding a non level-one edge, > but it's tricky to tell for sure just using gmv. The point is that the > problem doesn't seem to be systematic. > What I can tell is that there are non-level-1 constrained nodes that don't > involve spurious velocity vectors, but > without limiting nodal level mismatch we always find a region were the > solution blows up. > I'll investigate this and I'll send you some screenshots... > > >.) (Curiosity) How many more elements does flagging based on level-1 > > at the nodes introduce vs. not maintaining level-1 at the nodes? > > It seems that your mesh size would blow up quickly doing this. > > Not so quickly but actually with my 2Gb of ram i can't go further 80000 > elements in my simulations > (using GMRES/ILU with a restart of 400). > The resulting refined mesh is much more uniform than without > level-1-mismatch control, with an > increase of 10000/15000 elements over 80000. > > > Possibility 1 should be easy enough to test - run a > > DiscontinuityMeasure over your solutions and make sure the > > amount discontinuity it sees is on the order of floating point error. > > I'll try this... > Thanks a lot for your help. > > Lorenzo > > 2007/5/3, John Peterson : > > > > Roy Stogner writes: > > > On Thu, 3 May 2007, John Peterson wrote: > > > > > > > I'm glad you found that this works, but I wonder if it means there is > > > > a problem with the way we are constraining hanging "face" nodes on > > > > Tet10's, and this fix is just masking the bigger problem. > > > > > > It sounds like there's two possible problems on tets here. Either: > > > > > > 1. Our hanging nodes aren't producing conforming function spaces. > > > > > > Or: > > > > > > 2. The function spaces you get by only enforcing level-one > > > restrictions on faces aren't well-suited for Navier-Stokes. > > > > > > Possibility 1 should be easy enough to test - run a > > > DiscontinuityMeasure over your solutions and make sure the > > > amount discontinuity it sees is on the order of floating point error. > > > > > > For possibility 2, we might want to make "maintain_nodal_level_one" an > > > option along with "maintain_level_one". I don't want to make the > > > former behavior standard, since it would be a backwards-incompatible > > > behavior change and it might be too expensive for many users. However > > > making it an option would be a good idea. I'm thinking we deprecate > > > the maintain_level_one method argument and then make both options into > > > private MeshRefinement variables with accessor methods, like > > > refine_fraction and such. > > > > This is a good solution in the meantime, IMO. I'd still like to know > > what's going on with Navier-Stokes ... including why this doesn't show > > up (so far) on hexes. It seems that just having "fewer" > > greater-than-level-1 mismatched nodes in Hex meshes wouldn't be enough > > to prevent the problem, i.e. *any* greater-than-level-1 mismatched > > nodes should seemingly trigger it. > > > > I never got around to setting up a smooth (with smooth BCs) 3D > > Stokes/Navier-Stokes test problem. It seems that would be an important > > first step in testing your hypotheses above. If anyone has a suggestion > > I'd be happy to try it... > > > > -J > > ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-05-04 21:23 ```On Fri, 4 May 2007, John Peterson wrote: > The poor convergence of Newton does not appear to be due > to insufficient solution of the linear subproblems. This still seems to suggest a bug to me, but in our repeated testing we can only get similarly odd behavior out of the Stokes problem, not out of the Poisson problem on the same mesh. It's possible that there is no bug but that there's some LBB violation here which is making the velocity-pressure system underdefined or extraordinarily ill-conditioned; we'll try looking into that. In the meantime, we've changed the MeshRefinement API somewhat to try and make it easier to avoid meshes which trigger such problems. The method argument "maintain_level_one" has been replaced by accessors to options "face_level_mismatch_limit", "edge_level_mismatch_limit", and "node_level_mismatch_limit", which default to 1, 0 (i.e. "off"), and 0 respectively. Setting edge_level_mismatch_limit to 1 will hopefully prevent these sorts of awkwardly constrained hanging nodes from occuring, but without as much added expense as enforcing a node_level_mismatch_limit would entail. I've committed these options to CVS without giving them much testing, and John and I probably won't give them as much testing as they deserve, so Lorenzo, please give them a try. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-05-04 23:59 ```On Fri, 4 May 2007, Roy Stogner wrote: > This still seems to suggest a bug to me, but in our repeated testing > we can only get similarly odd behavior out of the Stokes problem, not > out of the Poisson problem on the same mesh. It's possible that there > is no bug but that there's some LBB violation here which is making the > velocity-pressure system underdefined or extraordinarily > ill-conditioned; we'll try looking into that. Interestingly enough, there was a bug (introduced by myself, in fact...) when running with Lagrange elements on meshes without the level-1 rule true across faces. This shouldn't have effected the case where level-1 regularity was true across faces but not edges, however. The bug still exists for non-Lagrange elements on non-level-1 regular meshes, so beware. I'll try to have a general fix posted to CVS this weekend, but it needs more testing. --- Roy ```

 Re: [Libmesh-users] AMR in 3D From: Shun Wang - 2007-05-06 04:44 Attachments: Message as HTML ```Hi, I didn't read through the whole post on the issue. But I found some similar problem for Hex8 elements. If you checked the attached the picture. This is a local mesh I get from libMesh AMR. There, both A and B are hanging nodes, while A depends on B. So when I do both dofmap.enforce_constraints_exactly(), A is interpolated from B and C, while B as a hanging node has value 0. Therefore, A gets a wrong value. I am guessing that libMesh level one condition is enforced only on surface, i.e. the level difference of two elements that share surfaces can not exceed one. If this is true, it could be a potential problem for hanging nodes. Is my conjecture right? How can I solve this problem? Thank you very much! -Shun ```

 Re: [Libmesh-users] AMR in 3D From: Shun Wang - 2007-05-06 04:56 Attachments: Message as HTML      3d_constrain_problem.JPG

 Re: [Libmesh-users] AMR in 3D From: Roy Stogner - 2007-05-06 05:03 ```On Sat, 5 May 2007, Shun Wang wrote: > If you checked the attached the picture. The picture didn't come through, but I take it you're talking about a situation where the mesh is level-1 regular on faces but there is a level-2 irregularity on edges? > This is a local mesh I get from libMesh AMR. There, both A and B > are hanging nodes, while A depends on B. So when I do both > dofmap.enforce_constraints_exactly(), A is interpolated from B and > C, while B as a hanging node has value 0. Therefore, A gets a > wrong value. Hmm... the bug I found Friday should only have affected meshes which have level-2 irregularities on sides, not just edges. If A is interpolated from B and C, while B is interpolated from (suppose) D and E, then enforce_constraints_exactly() is supposed to recursively build up a constraint matrix which directly interpolates A from C, D, and E. It's of course possible that there are bugs in this process. > I am guessing that libMesh level one condition is enforced only on > surface, i.e. the level difference of two elements that share surfaces can > not exceed one. > Is my conjecture right? How can I solve this problem? There are now options for enforcing level one regularity between edge and/or node neighbors in addition to face neighbors. If level-2 edge irregularities are causing problems for your particular formulation, using either of those options should fix it. However, even if your mesh has *no* regularity, libMesh is still supposed to ensure that your constrained finite element spaces have the appropriate level of continuity. If you're seeing an exception to that rule, it's a bug and we'd appreciate if you can give us more details or a reproducable test case. --- Roy ```