You can subscribe to this list here.
2003 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(2) 
_{Oct}
(2) 
_{Nov}
(27) 
_{Dec}
(31) 

2004 
_{Jan}
(6) 
_{Feb}
(15) 
_{Mar}
(33) 
_{Apr}
(10) 
_{May}
(46) 
_{Jun}
(11) 
_{Jul}
(21) 
_{Aug}
(15) 
_{Sep}
(13) 
_{Oct}
(23) 
_{Nov}
(1) 
_{Dec}
(8) 
2005 
_{Jan}
(27) 
_{Feb}
(57) 
_{Mar}
(86) 
_{Apr}
(23) 
_{May}
(37) 
_{Jun}
(34) 
_{Jul}
(24) 
_{Aug}
(17) 
_{Sep}
(50) 
_{Oct}
(24) 
_{Nov}
(10) 
_{Dec}
(60) 
2006 
_{Jan}
(47) 
_{Feb}
(46) 
_{Mar}
(127) 
_{Apr}
(19) 
_{May}
(26) 
_{Jun}
(62) 
_{Jul}
(47) 
_{Aug}
(51) 
_{Sep}
(61) 
_{Oct}
(42) 
_{Nov}
(50) 
_{Dec}
(33) 
2007 
_{Jan}
(60) 
_{Feb}
(55) 
_{Mar}
(77) 
_{Apr}
(102) 
_{May}
(82) 
_{Jun}
(102) 
_{Jul}
(169) 
_{Aug}
(117) 
_{Sep}
(80) 
_{Oct}
(37) 
_{Nov}
(51) 
_{Dec}
(43) 
2008 
_{Jan}
(71) 
_{Feb}
(94) 
_{Mar}
(98) 
_{Apr}
(125) 
_{May}
(54) 
_{Jun}
(119) 
_{Jul}
(60) 
_{Aug}
(111) 
_{Sep}
(118) 
_{Oct}
(125) 
_{Nov}
(119) 
_{Dec}
(94) 
2009 
_{Jan}
(109) 
_{Feb}
(38) 
_{Mar}
(93) 
_{Apr}
(88) 
_{May}
(29) 
_{Jun}
(57) 
_{Jul}
(53) 
_{Aug}
(48) 
_{Sep}
(68) 
_{Oct}
(151) 
_{Nov}
(23) 
_{Dec}
(35) 
2010 
_{Jan}
(84) 
_{Feb}
(60) 
_{Mar}
(184) 
_{Apr}
(112) 
_{May}
(60) 
_{Jun}
(90) 
_{Jul}
(23) 
_{Aug}
(70) 
_{Sep}
(119) 
_{Oct}
(27) 
_{Nov}
(47) 
_{Dec}
(54) 
2011 
_{Jan}
(22) 
_{Feb}
(19) 
_{Mar}
(92) 
_{Apr}
(93) 
_{May}
(35) 
_{Jun}
(91) 
_{Jul}
(32) 
_{Aug}
(61) 
_{Sep}
(7) 
_{Oct}
(69) 
_{Nov}
(81) 
_{Dec}
(23) 
2012 
_{Jan}
(64) 
_{Feb}
(95) 
_{Mar}
(35) 
_{Apr}
(36) 
_{May}
(63) 
_{Jun}
(98) 
_{Jul}
(70) 
_{Aug}
(171) 
_{Sep}
(149) 
_{Oct}
(64) 
_{Nov}
(67) 
_{Dec}
(126) 
2013 
_{Jan}
(108) 
_{Feb}
(104) 
_{Mar}
(171) 
_{Apr}
(133) 
_{May}
(108) 
_{Jun}
(100) 
_{Jul}
(93) 
_{Aug}
(126) 
_{Sep}
(74) 
_{Oct}
(59) 
_{Nov}
(145) 
_{Dec}
(93) 
2014 
_{Jan}
(38) 
_{Feb}
(45) 
_{Mar}
(26) 
_{Apr}
(41) 
_{May}
(125) 
_{Jun}
(70) 
_{Jul}
(61) 
_{Aug}
(66) 
_{Sep}
(60) 
_{Oct}
(110) 
_{Nov}
(27) 
_{Dec}
(30) 
2015 
_{Jan}
(43) 
_{Feb}
(67) 
_{Mar}
(71) 
_{Apr}
(92) 
_{May}
(39) 
_{Jun}
(15) 
_{Jul}
(46) 
_{Aug}
(63) 
_{Sep}
(84) 
_{Oct}
(82) 
_{Nov}
(69) 
_{Dec}
(45) 
2016 
_{Jan}
(92) 
_{Feb}
(91) 
_{Mar}
(148) 
_{Apr}
(43) 
_{May}
(58) 
_{Jun}
(117) 
_{Jul}
(92) 
_{Aug}
(140) 
_{Sep}
(49) 
_{Oct}
(33) 
_{Nov}
(85) 
_{Dec}
(40) 
2017 
_{Jan}
(41) 
_{Feb}
(36) 
_{Mar}
(49) 
_{Apr}
(41) 
_{May}
(73) 
_{Jun}
(51) 
_{Jul}
(12) 
_{Aug}
(69) 
_{Sep}
(26) 
_{Oct}
(43) 
_{Nov}
(75) 
_{Dec}
(20) 
S  M  T  W  T  F  S 





1

2
(1) 
3

4

5

6

7

8

9

10

11

12
(1) 
13
(7) 
14
(2) 
15
(2) 
16
(2) 
17
(2) 
18

19
(4) 
20
(1) 
21

22

23

24

25

26

27
(12) 
28
(7) 
29
(5) 
30
(4) 

From: Roy Stogner <roystgnr@ic...>  20050913 17:45:51

On Tue, 13 Sep 2005, Min Xu wrote: > I am thinking to attach two system to one equationsystem like: > > EquationSystems equation_systems (mesh); > > // The real system for diffusion equation > TransientLinearImplicitSystem & system = > equation_systems.add_system<TransientLinearImplicitSystem>("Diffusion"); > system.add_variable ("u", FIRST); > > // The dummy system for the coefficient alpha > LinearImplicitSystem & dummy = > equation_systems.add_system<LinearImplicitSystem>("Dummy"); > system.add_variable ("alpha", FIRST); This is one way to do things if you want both alpha and u to be defined on the same mesh, however unless you're going to be doing implicit solves for alpha you might want to make dummy an explicit system and avoid allocating an extra matrix. > The procedure follows: > (1) assign a coarse mesh and initialize the systems, mesh_psi = > mesh_alpha = mesh0. keep a copy of the mesh as mesh_coarse. You can keep a copy of the mesh, but alpha will always be defined on the mesh attached to equation_systems. If you want two different meshes for alpha and psi, there's currently no way to do so without two separate EquationSystems objects. > (1) If the two meshes are strictly that one is a refined version of the > another (maybe refined multiple times), is there a relative cheap way to use > alpha defined on the coarser mesh in the assemble routine for the equation > system? Any example for coefficients defined on a mesh? You're right that the problem is easier if one mesh is a superset of the other: if your alpha mesh is a coarser version of your psi mesh then a normal quadrature rule on psi will still be accurate when integrating terms containing alpha. However, the trick from a coding standpoint remains the same: in your assemble routine, you'll iterate through elements on the psi mesh. You'll need to integrate against data from the alpha mesh. This means you'll need to be able first to take a mesh_psi element and find the corresponding mesh_alpha element (via some map like I mentioned earlier) and second to take a mesh_psi master element point and find the corresponding mesh_alpha master element point (via inverse_map(), if you want to start with inefficient but correct and quicktoprogram code). > (2) Can project_vector work in a reverse direction, i.e., map a > vector defined on a finer mesh to a coarser mesh? If not, any > suggestion to implement such a projection? Currently the meshtomesh project_vector only works in the context of a single mesh whose elements are being refined and/or coarsened one level at a time, and so it's only meant to be called internally by the EquationSystems object. You could project all your EquationSystems vectors from a finer mesh to a much coarser mesh by repeatedly coarsening and calling EquationSystems::reinit(), but this is a one way process  you wouldn't be able to save fine mesh data. My suggestion would be to do such a projection with the same two EquationSystems objects you'd want to use for the rest of your problem. Either make alpha an implicit system and do an L2 projection, or simply do interpolation. Doing a projection would be the harder to code of the two choices, but would give you code portable to nonLagrange elements. Doing interpolation with Lagrange elements should be easy: iterate through all your mesh_alpha elements, find the corresponding mesh_phi elements, and copy over values. The mesh_phi elements will be inactive "ancestors", but they'll have the nodal data you want.  Roy Stogner 
From: John Peterson <peterson@cf...>  20050913 17:43:24

Min Xu writes: > > (1) If the two meshes are strictly that one is a refined version of the > another (maybe refined multiple times), is there a relative cheap way to use > alpha defined on the coarser mesh in the assemble routine for the equation > system? Any example for coefficients defined on a mesh? Not that I know of. In general two separate mesh objects MeshA and MeshB are entirely unrelated, and there's no way to tell them that they are related. If MeshA is a coarse submesh of MeshB, then theoretically it would be possible to coarsen the elements of MeshB in just the right way to obtain a Mesh identical to MeshA. (You would have to reproject the solution at each coarsening step, this wouldn't be "relatively cheap".) Seriously, just use a single mesh for all the variables :) > (2) Can project_vector work in a reverse direction, i.e., map a vector defined > on a finer mesh to a coarser mesh? If not, any suggestion to implement such a > projection? I don't think it can...as far as I know it only projects old vectors onto the current mesh. John 
From: Min Xu <minxu@sc...>  20050913 17:17:04

I am thinking to attach two system to one equationsystem like: EquationSystems equation_systems (mesh); // The real system for diffusion equation TransientLinearImplicitSystem & system = equation_systems.add_system<TransientLinearImplicitSystem>("Diffusion"); system.add_variable ("u", FIRST); // The dummy system for the coefficient alpha LinearImplicitSystem & dummy = equation_systems.add_system<LinearImplicitSystem>("Dummy"); system.add_variable ("alpha", FIRST); The procedure follows: (1) assign a coarse mesh and initialize the systems, mesh_psi = mesh_alpha = mesh0. keep a copy of the mesh as mesh_coarse. (2) solve the diffusion system and allow mesh_psi to be refined in its solution. obtain the update dalpha defined on mesh_psi_refined. (3) project dalpha to mesh_coarse which is the parent mesh of mesh_psi_refined. (4) Update alpha to alpha+dalpha, and refine the mesh for the dummy system to mesh_new_coarse. (5) Set mesh_psi=mesh_alpha=mesh_coarse=mesh_new_coarse and return to (2). My questions are: On Tuesday 13 September 2005 00:36, Roy Stogner wrote: > On Mon, 12 Sep 2005, Min Xu wrote: > > Can I just define a dummy EquationSystems to hold this parameter alpha > > and treat it as "solution", so all the operations on solution (mesh > > refinement and projection) can be used for alpha and then mapped to the > > diffusion equationSystems? Is there better ways to achieve it? > > This will work, but you'll have to have a separate mesh for each of > the two EquationSystems objects and you'll have to have some efficient > way of mapping between cells of one mesh and cells of the other. This > map could be two vectors, alpha_to_psi and psi_to_alpha, which each > are indexed by element ids from one mesh and return as data element > ids from the other. > > Unfortunately these ids are renumbered every time the mesh is changed. > So, after every EquationSystems::reinit() you'd need to regenerate > your map vectors from scratch, which could be an expensive process > unless you have a very coarse initial grid. Ideally the MeshData > class could be used to preserve enough data through refinement to make > this regeneration O(N), but like John I don't use MeshData myself. >  (1) If the two meshes are strictly that one is a refined version of the another (maybe refined multiple times), is there a relative cheap way to use alpha defined on the coarser mesh in the assemble routine for the equation system? Any example for coefficients defined on a mesh? (2) Can project_vector work in a reverse direction, i.e., map a vector defined on a finer mesh to a coarser mesh? If not, any suggestion to implement such a projection? Thanks! Min 
From: Roy Stogner <roystgnr@ic...>  20050913 04:36:46

On Mon, 12 Sep 2005, Min Xu wrote: > Can I just define a dummy EquationSystems to hold this parameter alpha and > treat it as "solution", so all the operations on solution (mesh refinement > and projection) can be used for alpha and then mapped to the diffusion > equationSystems? Is there better ways to achieve it? This will work, but you'll have to have a separate mesh for each of the two EquationSystems objects and you'll have to have some efficient way of mapping between cells of one mesh and cells of the other. This map could be two vectors, alpha_to_psi and psi_to_alpha, which each are indexed by element ids from one mesh and return as data element ids from the other. Unfortunately these ids are renumbered every time the mesh is changed. So, after every EquationSystems::reinit() you'd need to regenerate your map vectors from scratch, which could be an expensive process unless you have a very coarse initial grid. Ideally the MeshData class could be used to preserve enough data through refinement to make this regeneration O(N), but like John I don't use MeshData myself.  Roy Stogner 
From: John Peterson <peterson@cf...>  20050913 03:36:53

Min Xu writes: > The solution psi will also vary significantly nearby the source or detector > whereas the absorption alpha may just be uniform on these places. It is hence > beneficiary to use a more coarse mesh for alpha than that for psi. That may be true, but you will save yourself a lot of trouble and get started faster using a single mesh. > I am now leaning toward MeshData to store alpha. I read the mailing list > archive that MeshData did not support MeshRefinement yet. Have this situation > changed? Is it possible to use MeshRefinement to refine the MeshData in the > same way as the solution of an equation system is refined? How? I wish I knew more about MeshData, unfortunately I've never used it. John 
From: Min Xu <minxu@sc...>  20050913 02:41:10

The solution psi will also vary significantly nearby the source or detector whereas the absorption alpha may just be uniform on these places. It is hence beneficiary to use a more coarse mesh for alpha than that for psi. I am now leaning toward MeshData to store alpha. I read the mailing list archive that MeshData did not support MeshRefinement yet. Have this situation changed? Is it possible to use MeshRefinement to refine the MeshData in the same way as the solution of an equation system is refined? How? Thanks! Min On Monday 12 September 2005 21:22, John Peterson wrote: > Min Xu writes: > > Hi, > > > > I am a new libmesh user. I try to solve an optimization problem for the > > absorption alpha, governed by the diffusion equation: > > dpsi/dt = laplace(psi)  alpha*psi, > > such that the psi on the boundary matches the measurement. The > > absorption alpha is space dependent and need to be determined through > > optimization. > > > > The initial guess for alpha is uniform. I would like to use a coarse > > mesh for this parameter alpha initially and to refine this mesh > > gradually in the optimization process at locations where alpha changes > > abruptly. > > > > The solution psi will be solved on a different mesh which may start from > > the coefficient mesh and evolve independently. > > I wonder will you really need two separate meshes? It seems that psi will > vary a lot wherever alpha varies a lot  they are coupled. The one mesh > case I think is simpler than having multiple meshes. Then alpha is similar > to a "lagged" coefficient which gives you a new value of psi that in turn > feeds back in to determine the next alpha. > > John 
From: John Peterson <peterson@cf...>  20050913 01:22:32

Min Xu writes: > Hi, > > I am a new libmesh user. I try to solve an optimization problem for the > absorption alpha, governed by the diffusion equation: > dpsi/dt = laplace(psi)  alpha*psi, > such that the psi on the boundary matches the measurement. The absorption > alpha is space dependent and need to be determined through optimization. > > The initial guess for alpha is uniform. I would like to use a coarse mesh for > this parameter alpha initially and to refine this mesh gradually in the > optimization process at locations where alpha changes abruptly. > > The solution psi will be solved on a different mesh which may start from the > coefficient mesh and evolve independently. I wonder will you really need two separate meshes? It seems that psi will vary a lot wherever alpha varies a lot  they are coupled. The one mesh case I think is simpler than having multiple meshes. Then alpha is similar to a "lagged" coefficient which gives you a new value of psi that in turn feeds back in to determine the next alpha. John 