Need some hint to model an Earth Air Heat Exchanger

[Vincent-IUTRS-EOST]

Hello everybody,

I am currently working on an Earth Air Heat Exchanger model: the soil around the pipe is meshed with 3D elements and will solve the soil temperature diffusion (variable "ts"). Inside the pipe, the air is circulating in the direction Z (see figure which is a small part of the entire mesh) and I would like to implement the fluid one dimensional circulation inside the pipe by 1D elements using my own kernels (solving for the air velocity "vz", air pressure "p" and air temperature "ta"). In the air energy equation, associated to the variable "ta", I have a convective term of the form

h ( ta - ts_wall_mean) with ts_wall_mean = (1/2pi) integrate (theta=0->2pi) ts dtheta

so I declared "ts" inside the pipe 1D elements. My problem is to implement the constraint between "ts" in the pipe 1D elements and its counterpart in the soil 3D elements so that "ts" in the pipe is the mean value of "ts" around the wall soil boundary. I had a look at LinearNodalConstraint but I am not able to get the nodes id of the pipe wall/soil efficiently.
I successfully merged the soil mesh (from gmsh) and the pipe mesh (from gmsh too) since Moose does not read 1D elements for 3D meshes.

Does anyone can provide me some hint ?

[GiudGiud]

Hello

I think the best option here will be to look at thermal contact options. I m less familiar with them unfortunately.

Without this, or if it doesnt pan out, I would get started with an approach that does not properly compute the Jacobian, and solve with PJFNK, just to get started.
To do that, I would use:

• a nearestpointlayeredaverage to get axial averages in the 2D wall of the temperature
• a linevaluesampler (or again a layered average) to get the 1D values in the pipe
  Then
  You can make simple kernels restricted to the relevant elements implementing the convection equation
• a regular kernel for the 1D pipe. The nearestpointlayeredaverage will be an input and can return the axially dependent profile
• an interface kernel for the 2D elements. You ll have to add additional logic to axially map the linevaluesampler, but a layeredaverage should be able to return the direct value of the pipe temperature.

if this works, great.
If not then we need to consider the Jacobian entries. For this you will need to get the node ids (if they are nodal variables) or generally the dof ids. You ll need to build a user object that examines the mesh and finds the nodes and elements involved in the heat transfer and properly axially indexes them.
Then some constraint will take that list.

Other idea, easier to get started:
instead of a 1D pipe, just make a big 3D pipe, have it part of the 3D mesh and use interface kernels for convection between Ts and Tf
You can still have 1D flow, you ll just have a radial temperature profile in the pipe.

Guillaume

[Vincent-IUTRS-EOST]

Dear Guillaume,

Thank you for your answer. I tested a solution close to your first suggestion:

[Variables]
  [ts]
    family = LAGRANGE
    order  = FIRST
    block  = "SOIL"
  []
[]

[AuxVariables]
    [ts_wall]
      family = LAGRANGE
      order  = FIRST
      block  = "SOIL"
    []
    [ts_pipe]
      family = LAGRANGE
      order  = FIRST
      block  = "PIPE"
    []
  []

...... materials and kernels.......

[UserObjects]
  [./ts_wall_uo]
    type = LayeredSideAverage
    direction = z
    num_layers = 10
    variable = ts
    execute_on = 'ALWAYS'
    boundary = WALL
  [../]
[]

[AuxKernels]
  [./ts_wall_aux]
    type = SpatialUserObjectAux
    variable = ts_wall
    boundary = WALL
    user_object = ts_wall_uo
    execute_on = 'ALWAYS'
  [../]
  [./ts_pipe]
    type = NearestNodeValueAux
    paired_boundary = "WALL"
    paired_variable = ts_wall
    variable = ts_pipe
    execute_on = 'ALWAYS'
    boundary = "PIPE"
  [../]
[]

[VectorPostprocessors]
  [avg]
    type = SpatialUserObjectVectorPostprocessor
    userobject = ts_wall_uo
  []
[]

If the NearestNodeValueAux kernel is commented I correctly get the mean value of ts on the wall, but when I decomment this NearestNodeValueAux, I get the following error

*** ERROR ***
/home/vmagnenet/Projets_Moose/eahe/run/eahe.i:363: (AuxKernels/ts_pipe/boundary):
    the following node sets (ids) do not exist on the mesh: PIPE (8)

because "PIPE" is not a boundary..... I had a look at thermal contact but it seems also defined only for surfaces boundaries.

Your second idea (3D pipe) was my first idea ;-) , but I want to use classic fluid correlations for 1D flow in pipes (simplified heat equation with experimental correlations for head loss, convection versus Nusselt and Reynolds etc....) . I keep this solution in mind if the "good" previous approach fails.

Is there any way of creating a nodeset associated to the block of EDGE2 elements of "PIPE" ?

[GiudGiud]

In 1)
You are using an auxiliary variable to store the output of the layered average. You dont need to do this, you can query those values directly in your kernel.

If you want to use an auxiliary variable use a block instead of a boundary restriction. Your mesh is not a boundary for the pipe, it s a block

I m afraid the EDGE2 pipe is currently a block and there is no lower dimensional boundary to create from it within MOOSE
You would have to redo your mesh to make a nodeset as well as a block (to solve equations)

[Vincent-IUTRS-EOST]

Dear Guillaume,

After a long night making nightmares about MOOSE ;-) I finally found an easy way to get the model work. The air flow is solved in a small layer (called PIPE) and meshed with 3D elements and just near the soil interface (see figure below). To account for the convective term, I developed a small Kernel accounting for the width of the interface (I don't know if this kind of kernel already exists but I prefer having my own one):

Real
EAHE_Interface_Convective_Term::computeQpResidual()
{
  return -_hwall[_qp]*(_u[_qp]-_u_ext[_qp])*_test[_i][_qp]/_width[_qp];
}

Real
EAHE_Interface_Convective_Term::computeQpJacobian()
{
  return -_hwall[_qp]*_phi[_j][_qp]*_test[_i][_qp]/_width[_qp];
}

Real EAHE_Interface_Convective_Term::computeQpOffDiagJacobian(unsigned int jvar)
{
  Real jac=0.0;
  if(jvar==_u_ext_id)
    jac = +_hwall[_qp]*_u_ext_phi[_j][_qp]*_test[_i][_qp]/_width[_qp];
  return jac;
}

I ran this kernel for ts and ta :

[Kernels]

  ...... some kernels solving ts and ta except convective term

  # note that the diffusion of ts must be solved in the PIPE !

  [soil_interface_with_air] 
    type                 = EAHE_Interface_Convective_Term
    variable             = ts
    exterior_temperature = ta
    block                = "PIPE"
  []

  [air_interface_with_soil]
    type                 = EAHE_Interface_Convective_Term
    variable             = ta
    exterior_temperature = ts_mean_pipe
    block                = "PIPE"
  []

[]

where "ts_mean_pipe" is an auxvariable calculated as the mean value of "ts" in PIPE (integrating in theta and r only) calculated with a "NearestRadiusLayeredAverage" user object coupled to a "SpatialUserObjectAux" auxkernel.

The results were OK. There is no problem to add some new kernels solving the 1D flowing for the air pressure and air velocity in PIPE by using some kernel having a residue of the form:

time_term*test_i + 1D_vector_flow * _grad_test[_i][_qp](2)

since 2 (=Z) is the direction of the air flow (may be generalized by passing a flow direction vector as argument of the kernel). The thin width of the interface ensures no r dependence.

Well, I would like to thank you for all your answers, the forum keeps alive because cool developers spend some time answering newbies.

Best regards.