Operands ========= General information on operands ----------------------------- The two forms of operands under a keyword factor ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The operands under a factor keyword come in two forms: * operands specifying the topological entities where the loads are affected (keywords GROUP_NO and GROUP_MA, etc...). The arguments of these operands are the same for both operators. * the operand (s) specifying the values affected (TEMP, COEF_H, etc...). The meaning of these operands is the same for both operators but the arguments of these operands are all of the real type for the AFFE_CHAR_THER operator and of the function type (created by one of the DEFI_FONCTION, DEFI_NAPPE, DEFI_CONSTANTE,, FORMULE, or CALC_FONC_INTERP operators) for the AFFE_CHAR_THER_F operator. We will therefore not distinguish in this document, unless otherwise expressly stated, between the two operators AFFE_CHAR_THER and AFFE_CHAR_THER_F. Topological load assignment entities ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In general, the topological entities on which values should be assigned are defined: * by nodes using the GROUP_NO operand to introduce a list of groups of nodes, * per mesh using the GROUP_MA operand to introduce a list of cell groups, **Rule:** *To define the area of assignment as simply as possible, we use the overload rule, the last assignment that takes precedence.* Operand MODELE --------------- .. code-block:: text ♦ MODELE = me, Concept produced by the operator AFFE_MODELE [:external:ref:`U4.41.01 `] where the types of finite elements affected on the mesh are defined. Operand DOUBLE_LAGRANGE ------------------------ .. code-block:: text ◊ DOUBLE_LAGRANGE = 'OUI'/'NON' This keyword makes it possible to say whether or not the user wants to split the Lagrange multipliers used to define dualize the boundary conditions in the assembled matrix. Concretely, splitting the Lagrange multipliers makes it possible to use linear solvers that do not allow pivoting. Not duplicating the Lagranges makes it possible to reduce the number of degrees of freedom of the problem (and therefore the size of the problem to be solved) but its use is limited to solvers MUMPS and Petsc. Note that the two Lagrange multipliers associated with the relationship will be such that the first will be located before all the terms involved in the relationship and the second after, in the assembled matrix. This choice has the advantage of having an assembled matrix whose size is smaller but has the disadvantage of being able to make a singularity appear in the matrix. Since the numbering is in any case liable to be modified by the renumber of the external solver chosen, this detail therefore remains purely technical. Keyword TEMP_IMPO ----------------- But ~~~ Keyword factor that can be used to impose a temperature on nodes or groups of nodes. Depending on the name of the operator called, the values are supplied directly (AFFE_CHAR_THER) or through a function-like concept (AFFE_CHAR_THER_F). Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text TEMP_IMPO = _F (♦ | ALL = 'YES', | GROUP_NO = lgno, [l_gr_node] | GROUP_MA= lgma, [l_gr_mesh] ♦/TEMP = t, [R] /| TEMP_MIL=tinf, [R] | TEMP_INF=tinf, [R] | TEMP_SUP = tsup, [R] ) * for AFFE_CHAR_THER_F .. code-block:: text TEMP_IMPO = _F (♦ | ALL = 'YES', | GROUP_NO = lgno, [l_gr_node] | GROUP_MA= lgma, [l_gr_mesh] ♦/TEMP = tf, [function] /| TEMP_MIL = tf, [function] | TEMP_INF = tinf, [function] | TEMP_SUP = tsupf, [function] ) Operands ~~~~~~~~ .. code-block:: text /TEMP = Value of the **temperature** imposed on the specified node (s). .. code-block:: text /For thermal shell elements only (Modeling: 'COQUE'): .. code-block:: text | TEMP_MIL Temperature on the middle sheet imposed on the specified node (s). .. code-block:: text | TEMP_INF Temperature imposed on the lower wall of the shell. .. code-block:: text | TEMP_SUP Temperature imposed on the upper wall of the shell. These options make it possible to represent a parabolic variation in temperature in thickness. **Note:** The shell is oriented by the connectivity of the nodes of the associated mesh (cf. [:ref:`U3.01.00 `]). Let :math:`n` *the normal vector orienting the shell:* .. image:: images/1000000000000266000001788D76A7B399E3E6E9.png :width: 2.4283in :height: 1.6291in .. _RefImage_1000000000000266000001788D76A7B399E3E6E9.png: .. _RefNumPara__5384_1195630945: Keyword FLUX_REP ---------------- But ~~~ Keyword factor that can be used to apply **normal flows** to a **face** of a volume element or thermal shell defined by one or more **triangle** or **quadrangle** cells. This keyword also makes it possible to apply a normal flow to an edge (in 2 DPLAN or AXIS or AXIS_FOURIER) on segment-type meshes. Depending on the name of the operator called, the values are supplied directly (AFFE_CHAR_THER) or through a function-like concept (AFFE_CHAR_THER_F). Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text FLUX_REP = _F (♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦/FLUN = fl, [R] /| FLUN_INF = flin, [R] | FLUN_SUP = flsup, [R] ) * for AFFE_CHAR_THER_F .. code-block:: text FLUX_REP = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦/FLUN = flf, [function] /| FLUN_INF = flinf, [function] | FLUN_SUP = flsupf, [function] /| FLUX_X = flx, [function] | FLUX_Y = fly, [function] | FLUX_Z = flz, [function] ) Operands ~~~~~~~~ /FLUN: fl imposed flow normal to the mesh. This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG" "SEG2, SEG3 "," PLAN, AXIS, AXIS_FOURIER,, PLAN_DIAG, AXIS_DIAG" More precisely, the boundary condition applied is: :math:`\lambda (\mathrm{grad}T\cdot n)` = fl where :math:`\lambda` is the thermal conductivity and :math:`n` is the normal oriented in the direction of the numbering of the nodes in the mesh. The orientation convention is the one used in AFFE_CHAR_MECA [:ref:`U4.44.01 `]. .. code-block:: text /| FLUN_INF = flin | FLUN_SUP = flsup Normal flow imposed on the lower and upper walls of a thermal shell. These loads apply to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6 "," COQUE" :math:`n` being the normal orienting the surface [:ref:`U4.44.01 `], the boundary condition applied is: :math:`\lambda (\mathrm{grad}T\cdot n)` = flin where flin is the normal flow imposed on the lower wall of the shell, :math:`\lambda (\mathrm{grad}T\cdot n)` = flsup where flsup is the normal flow imposed on the upper wall of the shell. .. image:: images/1000000000000266000001788D76A7B399E3E6E9.png :width: 2.4283in :height: 1.6291in .. _RefImage_1000000000000266000001788D76A7B399E3E6E9.png0: .. code-block:: text /| FLUX_X = flx | FLUX_Y = fly | FLUX_Z = flz Vector flow :math:`\mathit{fl}` in the global coordinate system (only for AFFE_CHAR_THER_F) that is projected onto the normal of the element (for the definition of the normal [:ref:`U4.44.01 `]). :math:`\lambda (\mathit{grad}T\mathrm{\cdot }n)\mathrm{=}\mathit{fl}\mathrm{\cdot }n\mathrm{=}\mathit{flx.nx}+\mathit{fly.ny}+\mathit{flz.nz}` This loading applies to mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG" "SEG2, SEG3 "," PLAN PLAN_DIAG" Note: the persistence rule (see U1.03.00) applies between the different quantities that can be assigned: FLUN, FLUN_INF,... FLUX_Z. note ~~~~~~~~ The simple keyword CARA_TORSION for this FLUX_REP factor keyword is not documented here and should not be used by the user. It is only used for macro command MACR_CARA_POUTRE. This is used to identify the geometric characteristics of beam sections. For torsional characteristics, the control solves a Laplacian problem by using linear thermal operators indirectly. Keyword FLUX_NL --------------- But ~~~ Keyword factor that can be used to apply **normal flux** functions of temperature, to a **face** of a volume element defined by one or more **triangle** or **quadrangle** cells. This keyword also makes it possible to apply a normal flow to an edge (in 2 DPLAN or AXIS) on segment-type meshes. It is thus possible to model a radiation condition of the Stefan law type. This type of flow is only available in command AFFE_CHAR_THER_F and is only used by commands THER_NON_LINE [:ref:`U4.54.02 `] and THER_NON_LINE_MO [:ref:`U4.54.03 `]. The values are provided by a function-like concept. The function is temperature-dependent, excluding any other parameters. Furthermore, it is necessarily a tabulated function and not a formula. Syntax ~~~~~~ * For AFFE_CHAR_THER_F .. code-block:: text FLUX_NL = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦ FLUN = fl, [function] ) Operands ~~~~~~~~ .. code-block:: text FLUN: imposed flow normal to the mesh. This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG" "SEG2, SEG3 "," PLAN, AXIS PLAN_DIAG, AXIS_DIAG" More precisely, the boundary condition applied is: :math:`\lambda (\mathrm{grad}T\cdot n)` = fl where :math:`n` is the normal oriented in the direction of the numbering of the nodes in the mesh. Orientation used in AFFE_CHAR_MECA document [:ref:`U4.44.01 `]. Keyword RAYONNEMENT ------------------- But ~~~ Keyword used to define the radiated flux to infinity according to the formula: :math:`{\Phi }_{\mathit{ray}}\mathrm{=}\sigma \epsilon ({\mathrm{[}T+\mathrm{273,15}\mathrm{]}}^{4}\mathrm{-}{\mathrm{[}{T}_{\mathrm{\infty }}+\mathrm{273,15}\mathrm{]}}^{4})` by the emissivity data :math:`\varepsilon`, the Boltzmann constant :math:`\sigma` and the infinity temperature :math:`{T}_{\infty }` expressed in Celsius. Temperature :math:`T` will also be expressed in Celsius, so care must be taken, for consistency, to use only degrees Celsius for the whole study. Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text RAYONNEMENT = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦ SIGMA = sigma, [:ref:`R8 `] ♦ EPSILON = epsilon, [:ref:`R8 `] ♦ TEMP_EXT = tex, [:ref:`R8 `] ) * for AFFE_CHAR_THER_F .. code-block:: text RAYONNEMENT = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦ SIGMA = sigma, [function] ♦ EPSILON = epsilon, [function] ♦ TEMP_EXT = tex, [function] ) Operands ~~~~~~~~ .. code-block:: text ♦ SIGMA = sigma ♦ EPSILON = Epsilon ♦ TEMP_EXT = tex This load applies to the following models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG" "SEG2, SEG3 "," PLAN, AXIS PLAN_DIAG, AXIS_DIAG" .. csv-table:: "sigma:", "Boltzmann constant, :math:`\sigma \mathrm{=}5.67{10}^{\mathrm{-}8}` in SI units (:math:`W\mathrm{/}{m}^{2}\mathrm{.}{K}^{4}`) (pay attention to this value if the mesh units change)," "epsilon:", "emissivity," "tex:", "temperature to infinity in degrees Celsius." .. _RefNumPara__20110_527440489: Keyword ECHANGE --------------- But ~~~ Keyword factor that can be used to apply **exchange conditions** with an external temperature to a **face** of solid elements or shells, defined by one or more **triangle** or **quadrangle** cells. This keyword also makes it possible to apply exchange conditions to an edge (in 2D PLAN or AXIS or AXIS_FOURIER) on segment-type meshes. Depending on the name of the operator called, the values are supplied directly (AFFE_CHAR_THER) or through a function-like concept (AFFE_CHAR_THER_F). Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text ECHANGE = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦/♦ COEF_H = h, [R] ♦ TEMP_EXT = tex, [R] .. code-block:: text /| ♦ COEF_H_INF = yes, [R] ♦ TEMP_EXT_INF = texin, [R] | ♦ COEF_H_SUP = hsup, [R] ♦ TEMP_EXT_SUP = texsup, [R] ) * for AFFE_CHAR_THER_F .. code-block:: text ECHANGE = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦/♦ COEF_H = hf, [function] ♦ TEMP_EXT = texf, [function] .. code-block:: text /| ♦ COEF_H_INF = hinf, [function] ♦ TEMP_EXT_INF = texinf, [function] | ♦ COEF_H_SUP = hsupf, [function] ♦ TEMP_EXT_SUP = texsupf, [function] ) Operands ~~~~~~~~ /♦ COEF_H = h, ♦ TEMP_EXT = tex, This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG" "SEG2, SEG3 "," PLAN, PLAN_DIAG AXIS, AXIS_FOURIER, AXIS_DIAG" More precisely, the boundary condition applied is: :math:`\lambda (\mathit{grad}T\mathrm{\cdot }n)\mathrm{=}h(\mathit{tex}\mathrm{-}T)(h>0)` where :math:`n` is the normal oriented in the direction of the numbering of the vertex nodes (orientation used in AFFE_CHAR_MECA [:ref:`U4.44.01 `]). .. code-block:: text /| ♦ COEF_H_INF = yes, ♦ TEMP_EXT_INF = Texan, | ♦ COEF_H_SUP = hsup, ♦ TEMP_EXT_SUP = texsup, This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6 "," COQUE" :math:`n` being the normal orienting the surface [:external:ref:`U2.03.03 `], the boundary condition applied is: :math:`\lambda (\mathrm{grad}T\cdot n)=\mathrm{hin}(\mathrm{texin}-T)` .. csv-table:: "where hin", "exchange coefficient on the lower wall of the shell," "and texin", "outside temperature, on the lower wall side." :math:`\lambda (\mathrm{grad}T\cdot n)=\mathrm{hsup}(\mathrm{texsup}-T)` .. csv-table:: "where hsup", "exchange coefficient on the upper wall of the shell," "and texsup", "outside temperature, outside wall side." Notes: * the persistence rule (see U1.03.00) applies between the different quantities that can be assigned: COEF_H, COEF_H_INF,... TEMP_EXT_SUP. *In the case of functional loads (AFFE_CHAR_THER_F), as there are two distinct components (the exchange coefficient and the temperature), which are*a priori* independent, we cannot use this load simultaneously with a multiplier function in the resolution operator (THER_LINEAIRE or THER_NON_LINE). An error message will alert you. Keyword SOURCE -------------- But ~~~ Keyword factor that can be used to apply **volume sources** (2D or 3D) to a **domain** defined by one or more **volumic** cells. Depending on the name of the operator called, the values are supplied directly (AFFE_CHAR_THER) or through a function-like concept (AFFE_CHAR_THER_F). This load accepts functions that depend on command variables. Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text SOURCE =_F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦/SOUR = s, [R] /SOUR_CALCULEE = chs, [cham_elem] ) * for AFFE_CHAR_THER_F .. code-block:: text SOURCE =_F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦ SOUR = sf, [function] ) Operands ~~~~~~~~ This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "HEXA8, HEXA20, HEXA27 PYRA5, PYRA13, PENTA6, PENTA15 TETRA4, TETRA10 ", "3D, 3D_ DIAG" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 "," PLAN, PLAN_DIAG, AXIS, AXIS_FOURIER AXIS_DIAG" .. code-block:: text /♦ SOUR = s, Source value assumed to be constant on the element. .. code-block:: text /♦ SOUR_CALCULEE = chs, Name of the field _Elem_Sour_R containing on each element the values of the source discretized at the Gauss points (1st family). Keyword PRE_GRAD_TEMP --------------------- But ~~~ Keyword factor that can be used to apply to a 3D or 2D element (PLAN, AXIS) a temperature gradient that is assumed to be uniform in the element. This "initial" temperature gradient can be used for example to solve the elementary problems determining the correctors of stationary linear thermal in the base cell (2D, 3D), in periodic homogenization. The homogenized conductivity coefficients are obtained by calculating by the operator POST_ELEM [:ref:`U4.81.22 `] keyword ENER_POT the energy dissipated thermally at linear thermal equilibrium using the correctors using the correctors. Because of the thermal analogy, this approach can be exploited to obtain the correctors in antiplane elasticity in the 2D base cell, as well as in electrical conduction. The calculation uses the conductivity of the material. This is assumed to be isotropic and independent of temperature. The assignment can be done on one or more cells or on all the elements of the model. Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text PRE_GRAD_TEMP = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦ | FLUX_X = flx, [R] | FLUX_Y = fly, [R] | FLUX_Z = flz, [R] ) Operands ~~~~~~~~ This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 "," PLAN, AXIS, PLAN_DIAG, AXIS_DIAG" "HEXA8, HEXA20, HEXA27 PENTA6, PENTA15, TETRA4, TETRA10 PYRA5, PYRA13 ", "3D, 3D_ DIAG" .. code-block:: text ♦ | FLUX_X = flx (flxf) | FLUX_Y = fly (flyf) | FLUX_Z = flz (flzf) (in 3D only) Components of the :math:`\mathrm{grad}{T}_{\mathrm{ini}}` temperature gradient in the global coordinate system. The second elementary member calculated is: :math:`{\int }_{{V}_{e}}\mathrm{grad}{T}_{\mathrm{ini}}K\mathrm{grad}{T}^{\text{*}}{\mathrm{dV}}_{e}` where :math:`K` is the thermal conductivity tensor. Gradients may be a function of geometry and/or time. * for AFFE_CHAR_THER_F .. code-block:: text PRE_GRAD_TEMP = _F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] .. code-block:: text ♦ | FLUX_X = flxf, [function] | FLUX_Y = flyf, [function] | FLUX_Z = flzf, [function] ) Keyword LIAISON_DDL ------------------- But ~~~ Keyword factor that can be used to define a linear relationship between degrees of freedom of two or more nodes. Depending on the name of the operator called, the values are supplied directly (AFFE_CHAR_THER) or through a function concept (AFFE_CHAR_THER_F). Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text LIAISON_DDL = _F (♦ GROUP_NO = lgno, [l_gr_node] ◊ DDL = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ♦ COEF_MULT = ai, [L_r] ♦ COEF_IMPO = b, [R] ) * for AFFE_CHAR_THER_F .. code-block:: text LIAISON_DDL = _F (♦ GROUP_NO = lgno, [l_gr_node] ◊ DDL = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ♦ COEF_MULT = ai, [L_r] ♦ COEF_IMPO = bf, [function] ) Operands ~~~~~~~~ The list of nodes :math:`{N}_{i}` (:math:`i\mathrm{=}\mathrm{1,}r`) defined by GROUP_NO is ordered in a natural way, that is, in the order of the list of groups of nodes, and for each group of nodes, in the order in which the group is defined by GROUP_NO. The argument for DDL should be a list of degrees of freedom :math:`{T}_{i}` (:math:`i\mathrm{=}\mathrm{1,}r`) from :math:`r` texts taken from: 'TEMP', 'TEMP_MIL', 'TEMP_SUP', '', 'TEMP_INF', 'H1' If the DDL keyword is omitted, by default the linear relationship will be based on the degrees of freedom 'TEMP'. The argument to COEF_MULT should be a :math:`{a}_{i}` (:math:`i\mathrm{=}\mathrm{1,}r`) list of coefficients (real type for AFFE_CHAR_THER and AFFE_CHAR_THER_F). The argument for COEF_IMPO is a :math:`\beta` coefficient for AFFE_CHAR_THER, a space function for AFFE_CHAR_THER_F. The following kinematic condition is applied: :math:`\mathrm{\sum }_{i\mathrm{=}1}^{r}{\alpha }_{i}{T}_{i}\mathrm{=}\beta` **Notes:** *The components* *' TEMP_MIL ',' TEMP_SUP ', and* *' TEMP_INF 'can only be used in combinations assigned* **only to nodes that belong to elements of* **shell (modeling* *' COQUE') .* *The* 'H1' component*can only intervene in combinations assigned* **only to nodes that belong to elements* **X- FEM. In this case, only the degrees of liberty* 'TEMP' *and* 'H1' *can be included in the linear relationship.* *In the case of a linear relationship between the degrees of freedom of the same node, we will repeat behind the keyword* *GROUPE_NOle name of the group defining the node as many times as there are degrees of freedom in the relationship.* **Example:To impose* :math:`{T}_{\text{sup}}\mathrm{=}{T}_{\text{inf}}` *on the group node* :math:`\mathit{GN}1` *, we will write:* .. code-block:: text LIAISON_DDL = _F (GROUP_NO = (GN1, GN1), DDL = ('TEMP_SUP', 'TEMP_INF'), COEF_MULT = (1., -1. ), COEF_IMPO = 0. , ) *It is important to note that at one occurrence of the keyword factor* * *LIAISON_DDLcorrespond there is only one linear relationship.* *If you want to impose the same relationship between 2 groups of nodes* *GRN01et* * *GRN02 (same temperature node to node for example)* **you cannot write:** .. code-block:: text LIAISON_DDL = _F (GROUP_NO = (GRN01, GRN02), DDL = ('TEMP', 'TEMP'), COEF_MULT = (1., -1. ), COEF_IMPO = 0.,) *This spelling only makes sense if* *GRN01et* * *GRN02ne each contain only one node. In the case above, it will be necessary to explain each linear relationship, node by node.* **The keyword** **LIAISON_GROUP, on the other hand, allows you to condense the writing of linear relationships between 2 groups of nodes facing each other.** Keyword LIAISON_GROUP --------------------- But ~~~ Keyword factor that can be used to define linear relationships between pairs of nodes, these pairs of nodes being obtained by facing each other two lists of meshes or nodes. Depending on the name of the operator called :math:`N`, the values are supplied directly (AFFE_CHAR_THER) or through a function concept (AFFE_CHAR_THER_F). Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text LIAISON_GROUP =_F (♦/♦ GROUP_MA_1 = lgma1, [l_gr_mesh] ♦ GROUP_MA_2 = lgma2, [l_gr_mesh] /♦ GROUP_NO_1 = lgno1, [l_gr_node] ♦ GROUP_NO_2 = lgno2, [l_gr_node] ◊ SANS_GROUP_NO = lgno, [l_gr_node] ◊ DDL_1 = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ◊ DDL_2 = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ♦ COEF_MULT_1 = a1i, [L_r] ♦ COEF_MULT_2 = a2i, [L_r] ♦ COEF_IMPO = b, [R] ◊ | CENTER = lr, [L_r] | ENGL_TOP = or, [L_r] | TRAN = lr, [l_R] ) * for AFFE_CHAR_THER_F .. code-block:: text LIAISON_GROUP =_F (♦/♦ GROUP_MA_1 = lgma1, [l_gr_mesh] ♦ GROUP_MA_2 = lgma2, [l_gr_mesh] /♦ GROUP_NO_1 = lgno1, [l_gr_node] ♦ GROUP_NO_2 = lgno2, [l_gr_node] ◊ SANS_GROUP_NO = lgno, [l_gr_node] ◊ DDL_1 = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ◊ DDL_2 = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', | 'H1', ♦ COEF_MULT_1 = a1i, [L_r] ♦ COEF_MULT_2 = a2i, [L_r] ♦ COEF_IMPO = bf, [function] .. _OLE_LINK1: ◊ | CENTER = lr, [L_r] | ENGL_TOP = or, [L_r] | TRAN = lr, [l_R] ) Operands ~~~~~~~~ .. image:: images/10000000000001740000015418D06393CBAF16FA.png :width: 2.6764in :height: 2.361in .. _RefImage_10000000000001740000015418D06393CBAF16FA.png: **Figure 4.11.3-a: Geometric transformation** **from one border to another** "General" kinematic condition: :math:`\mathrm{\sum }_{i\mathrm{=}1}^{\mathit{NDDL1}}{{\alpha }_{\mathrm{1i}}{T}_{i}\mathrm{\mid }}_{{\Gamma }_{1}}+\mathrm{\sum }_{i\mathrm{=}1}^{\mathit{NDDL2}}{{\alpha }_{\mathrm{2i}}{T}_{i}\mathrm{\mid }}_{{\Gamma }_{2}}\mathrm{=}\beta` .. code-block:: text /♦ GROUP_MA_1 = This operand defines :math:`{\Gamma }_{1}` through the meshes that compose it. .. code-block:: text ♦ GROUP_MA_2 = This operand defines :math:`{\Gamma }_{2}` through the meshes that compose it. .. code-block:: text /♦ GROUP_NO_1 = This operand defines :math:`{\Gamma }_{1}` through the nodes that compose it. .. code-block:: text ♦ GROUP_NO_2 = This operand defines :math:`{\Gamma }_{2}` through the nodes that compose it. .. code-block:: text ◊ SANS_GROUP_NO = This operand makes it possible to remove from the list of pairs of nodes in respect of all pairs in which at least one of the nodes belongs to the given list of nodes. This makes it possible to avoid the accumulation of linear relationships on the same node during different iterations on the keyword factor LIAISON_GROUP, which most of the time leads to a singular matrix. .. code-block:: text ♦ COEF_MULT_1 (resp. COEF_MULT_2) List of reals exactly sized to the number of degrees of freedom declared in DDL_1 (resp. DDL_2) corresponding to the multiplier coefficients of the linear relationship. .. code-block:: text ♦ COEF_IMPO: blocking coefficient of the linear relationship: .. csv-table:: ":math:`\beta` ", ":", "real for AFFE_CHAR_THER" ":math:`{\beta }_{f}` ", ":", "function for AFFE_CHAR_THER_F" .. code-block:: text ◊ CENTRE: coordinates of the center of rotation ◊ ANGL_NAUT: nautical angles in degrees defining the rotation (see AFFE_CARA_ELEM [:external:ref:`U4.42.01 `] keyword ORIENTATION) ◊ TRAN: components of the translation vector These operands make it possible to define an approximate virtual transformation (rotation and/or translation) from :math:`{\Gamma }_{1}` to :math:`{\Gamma }_{2}` in order to ensure the bijectivity of the function with respect to each other. .. code-block:: text ◊ DDL_1 (resp. DDL_2): List of texts taken from: .. code-block:: text 'TEMP', 'TEMP_MIL', 'TEMP_INF', '', 'TEMP_SUP', 'H1' 'TEMP_MIL', 'TEMP_INF' and 'TEMP_SUP' can only be used for thermal shell elements (modeling: 'COQUE'). 'H1' can only be used for X- FEM elements. In this case, only the degrees of freedom 'TEMP' and 'H1' can be included in the linear relationships. By default, the degree of freedom considered for all nodes in linear relationships is' TEMP '. Using LIAISON_GROUP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * LIAISON_GROUP only generates linear relationships between 2 nodes (one on :math:`{\Gamma }_{1}`, one on :math:`{\Gamma }_{2}`) To generate linear relationships on more than 2 nodes, use the LIAISON_DDL keyword. * determination of the pairs of knots facing each other: first, we establish the two lists of nodes to be placed facing each other (i.e. to be matched), for each occurrence of the keyword factor LIAISON_GROUP: * for the keywords GROUP_NO_1 and GROUP_NO_2, these are the nodes constituting the groups of nodes, * for the keywords GROUP_MA_1 and GROUP_MA_2, these are the mesh nodes constituting the mesh groups. Since redundancies are eliminated, the two lists of nodes obtained must have the same length. The determination of the pairs of knots facing each other is done in several steps: * for each node :math:`\mathit{N1}` in the first list, we look for the image node :math:`\mathit{N2}\mathrm{=}f(\mathit{N1})` in the second list. If f is not injective (a :math:`\mathit{N2}` node is the image of two distinct nodes :math:`\mathit{N1}` and :math:`\mathit{N1}\text{'}`), the following error message is issued: .. code-block:: text CONFLIT DANS LES VIS -A- VIS DES NOEUDS THE NOEUD N2 EST THE VIS -A- VIS DES NOEUDS N1 AND N1' * for each :math:`\mathit{N2}` node in the second list, we look for the image node :math:`\mathit{N1}\mathrm{=}g(\mathit{N2})` in the first list. If g is not injective (a :math:`\mathit{N1}` node is the image of two distinct nodes :math:`\mathit{N2}` and :math:`\mathit{N2}\text{'}`), the following error message is issued: .. code-block:: text CONFLIT DANS LES VIS -A- VIS DES NOEUDS THE NOEUD N1 EST THE VIS -A- VIS DES NOEUDS N2 AND N2' * we check that :math:`g\mathrm{=}{f}^{\mathrm{-}1}`, that is to say that the pairs obtained by steps a) and b) are the same (we want to have a :math:`f` bijection between the two lists of nodes). If f is not surjective, the following error message is output: .. code-block:: text CONFLIT DANS LES VIS -A- VIS GENERES SUCCESSIVEMENT A PARTIR DES LISTES LIST1 AND LIST2 THE NOEUD OF THE PREMIERE LISTE N1 N'EST THE IMAGE OF AUCUN NOEUD PAR THE CORRESPONDANCE INVERSE For a given node :math:`N`, we call image node :math:`f(N)` the node from the other list of nodes that achieves the minimum distance with :math:`N`. To facilitate matching, especially in the case of particular geometries (where borders :math:`{\Gamma }_{1}` and :math:`{\Gamma }_{2}` could "almost" be deduced from each other by the composition of a translation and a rotation), we offer the possibility of doing a virtual geometric transformation of the first group of nodes (translation and rotation (cf. [Figure 4.11.3-a]) before calculating the distances (keywords TRAN, CENTRE and ANGL_NAUT). For each occurrence of the keyword factor LIAISON_GROUP, the list of new couples facing each other is thus constructed. Once you have scanned all the occurrences, you remove duplicate couples from the list. **Note:** *In pairs of knots facing each other, the order of the knots is important. If for the first occurrence of* *LIAISON_GROUP, a node* :math:`N` *belonged to the first group of nodes and a node* :math:`M` *to the second group of nodes, and for the second occurrence of* *LIAISON_GROUP, it is the opposite, we will obtain at the end of the pairing the couples* :math:`(N,M)` *and* :math:`(M,N)` *. They will not be eliminated when redundancies are detected; on the other hand, the matrix obtained will be singular. Thus, it is recommended to keep the same logic when describing opposite edges.* Keyword LIAISON_MAIL -------------------- But ~~~ Keyword factor that allows two edges of a structure to be "thermally glued together". These edges can be meshed differently (incompatible meshes) but must be deduced from each other by rotation and/or translation. Syntax ~~~~~~ * in AFFE_CHAR_THER only .. code-block:: text LIAISON_MAIL =_F (♦ GROUP_MA_MAIT = lgma_ait, ♦ | GROUP_MA_ESCL = lgma_escl, | GROUP_NO_ESCL = lgno_escl, ◊ DISTANCE_MAX = d_max, [R] ◊ | ♦ TRAN = (tx, ty, [tz]), [l_R] | ♦ CENTER = (xx, yc, [zc]), [l_R] ♦ ANGL_NAUT = (alpha, [beta, gamma]), [L_r] ) Side 1 is called the "master" side; side 2 is called the "slave" side. Operands ~~~~~~~~ GROUP_MA_ESCL/GROUP_NO_ESCL ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ These keywords make it possible to define all the nodes on the slave face. We take all the nodes specified by the GROUP_NO_ESCL keyword plus possibly the nodes carried by the meshes specified by the GROUP_MA_ESCL keyword. GROUP_MA_MAIT ^^^^^^^^^^^^^ This keyword makes it possible to define the set of meshes where one will look for the opposite of the nodes on the slave face. You should not give the surface cells (in 3D) composing the master face, but the volume cells adjacent to the master face. The specified meshes are candidates for the search for opposites. You can give too much. DISTANCE_MAX ^^^^^^^^^^^^ To project mesh :math:`\mathit{MA1}` onto mesh :math:`\mathit{MA2}`, the method looks for which element of mesh :math:`\mathit{MA1}` each node of :math:`\mathit{MA2}` is in, then interpolates the value using the element's shape functions. When a :math:`\mathit{MA2}` node is not in any element of the :math:`\mathit{MA1}` mesh, the method relates the node to the point (edge) of the closest element. It interpolates the value using the element's shape functions even if the node is "far away" from this element. If we want a node that is not in any of the elements of mesh :math:`\mathit{MA1}`, not to be involved in the projection, we use the DISTANCE_MAX operand. This operand allows you to give the maximum distance that is allowed between the node and the nearest element. If the node does not meet the proximity criterion the field will not be projected onto this node (i.e. the node will not carry any components). There is no default value for DISTANCE_MAX. This means that by default, the field will be extended outside the subject as far as needed. DISTANCE_ALARME = d_ala ^^^^^^^^^^^^^^^^^^^^^^^^^^ The code sounds an alarm when a :math:`\mathit{MA2}` node is deemed "far away" from the :math:`\mathit{MA1}` mesh. Consider dthe distance between a :math:`\mathit{MA2}` node and the nearest :math:`\mathit{MA1}` mesh. By default, the criterion for judging whether a node is remote is relative: d > 1/10th the size of the nearest mesh. But if the user uses DISTANCE_ALARME = d_ala, the alarm message is sent if d > d_ala (absolute criterion). CENTRE/ANGL_NAUT/TRAN ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ These operands make it possible to define the geometric transformation (rotation and/or translation) making it possible to go from the slave face to the master face. The command performs the rotation first and then the translation. Attention: the transformation is in the slave-master direction. This boundary condition applies to plane ('PLAN' or 'AXIS') or solid ('3D') models. Keyword ECHANGE_PAROI --------------------- But ~~~ Keyword factor that can be used to apply heat exchange conditions between 2 walls. These walls can be defined in two ways: * each separately, by one or more meshes (case of mesh walls); * based on a list of cracks X- FEM, the two walls then corresponding to the two lips of each crack. In this case it is also possible to impose the continuity of the temperature field through the lips of each crack. Syntax ~~~~~~ * for AFFE_CHAR_THER .. code-block:: text ECHANGE_PAROI =_F ( # if the wall is meshed ♦ GROUP_MA_1 = lgma, [l_gr_mesh] ♦ GROUP_MA_2 = lgma, [l_gr_mesh] ♦ COEF_H = h, [R] ◊ TRAN = lr, [L_r] # if the wall is defined with cracks X- FEM ♦ FISSURE = lfiss, [l_fiss_xfem] ♦/COEF_H = h, [R] /TEMP_CONTINUE = 'OUI' ) * for AFFE_CHAR_THER_F .. code-block:: text ECHANGE_PAROI =_F ( # if the wall is meshed ♦ GROUP_MA_1 = lgma, [l_gr_mesh] ♦ GROUP_MA_2 = lgma, [l_gr_mesh] ♦ COEF_H = h, [function] ◊ TRAN = lr, [L_r] # if the wall is defined with cracks X- FEM ♦ FISSURE = lfiss, [l_fiss_xfem] ♦/COEF_H = h, [function] /TEMP_CONTINUE = 'OUI' ) Operands ~~~~~~~~ Case of mesh walls ^^^^^^^^^^^^^^^^^^^^^^^^^ .. code-block:: text ♦ COEF_H Exchange coefficient between the 2 walls. Real for operator AFFE_CHAR_THER, function for operator AFFE_CHAR_THER_F. .. code-block:: text ♦ GROUP_MA_1 ♦ GROUP_MA_2 .. image:: images/10000000000001740000015418D06393CBAF16FA.png :width: 2.6764in :height: 2.361in .. _RefImage_10000000000001740000015418D06393CBAF16FA.png0: **Figure 4.13.3-a** These operands make it possible to define the 2 lists of cells representing for the indexed list "_1" the wall :math:`{\Gamma }_{1}` for the indexed list "_2" representing the wall :math:`{\Gamma }_{2}`. The walls are in correspondence and must have the same number of stitches and knots. The limit condition applied between these 2 walls is: on :math:`{\Gamma }_{1}`: :math:`k\frac{\partial {T}_{1}}{\partial {n}_{1}}=h\left({T}_{2}-{T}_{1}\right)` :math:`{n}_{1}` normal outdoor to :math:`{\Gamma }_{1}` on :math:`{\Gamma }_{2}`: :math:`k\frac{\partial {T}_{2}}{\partial {n}_{2}}=h({T}_{1}-{T}_{2})` :math:`{n}_{2}` normal outdoor to :math:`{\Gamma }_{2}` where :math:`\begin{array}{}{{T}_{1}\mid }_{{\Gamma }_{1}}=T\\ {{T}_{1}\mid }_{{\Gamma }_{2}}=T°{f}^{-1}\end{array}` :math:`\begin{array}{c}{{T}_{2}\mathrm{\mid }}_{{\Gamma }_{1}}\mathrm{=}T\mathrm{°}f\\ {{T}_{2}\mathrm{\mid }}_{{\Gamma }_{2}}\mathrm{=}T\end{array}` :math:`f` representing the bijection that puts a :math:`{\Gamma }_{1}` node and a :math:`{\Gamma }_{2}` node facing each other. .. code-block:: text ◊ TRAN Components of the translation vector. This operand makes it possible to define an approximate virtual (translation) transformation from :math:`{\Gamma }_{1}` to :math:`{\Gamma }_{2}` in order to ensure the bijectivity of the opposite function. TRANcaractérise a translation: .. code-block:: text .. csv-table:: "in 2D we therefore have", ":", "TRAN =( tx, ty)" "in 3D we have", ":", "TRAN =( tx, ty, tz)" Case of one or more cracks X- FEM ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. code-block:: text ♦ FISSURE List of cracks X- FEM. For each crack given in this list, the two opposing walls are defined as the upper lip and the lower lip of the crack. There are therefore as many pairs of walls facing each other as there are cracks present in this list. .. code-block:: text ♦/COEF_H Exchange coefficient between the lips of the crack. Real for operator AFFE_CHAR_THER, function for operator AFFE_CHAR_THER_F. If this keyword is present, the exchange condition imposed between the lips of each crack given under the keyword FISSUREest the same as in the case of a mesh wall (see previous §), taking the identity for the :math:`f` bijection since the upper and lower lips of each crack are geometrically coincident. .. code-block:: text /TEMP_CONTINUE This keyword can only be filled in with the value 'OUI'. If this keyword is present, the continuity of the temperature field is imposed across the lips of each crack given under the keyword FISSURE, by cancelling the degrees of freedom for enrichment ("Heaviside" and "crack-tip"). Using ECHANGE_PAROI ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *In the case of a mesh wall:* The user gives two lists of meshes from which the pairs of paired knots will come from. These lists are first sorted by mesh type: the matched knots will come from meshes of the same type. For each mesh in the first list, we determine the closest mesh in the second list by calculating all the distances of the nodes taken in pairs (we go through all the possible permutations). The minimum distance obtained defines both the mesh facing each other and the pairs of paired knots for the two cells concerned. As in LIAISON_GROUP [:ref:`§4.11 <§4.11>`], it is possible to perform a virtual geometric transformation (rotation and/or translation) before calculating the distances. *In the case of one or more cracks X- FEM:* We define as many pairs of walls facing each other as there are cracks in the list entered for the keyword FISSURE. * If the keyword COEF_H is present, all cracks in this list will have the same exchange coefficient (real or functional). To assign an exchange coefficient value specific to each crack, it is necessary to use the repeatability of the keyword factor ECHANGE_PAROI. * If the TEMP_CONTINUE keyword is present, the continuity of the temperature field is enforced through all the cracks in this list. Meshes and models supporting this load: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ *In the case of mesh walls:* The lists of cells given by the user must consist of edge cells, coupling cells are then automatically generated. The table below provides a summary of the edge meshes as well as the models for which this type of loading is supported. .. csv-table:: "**Edge mesh**", "**Modeling**", "**Coupling mesh generated**" "SEG2, SEG3 "," PLAN, PLAN_DIAG AXIS, AXIS_DIAG "," SEG22, SEG33" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 ", "3D, 3D_ DIAG "," TRIA33, TRIA66, QUAD44, QUAD88, QUAD99" *In the case of one or more cracks X- FEM:* The cracks must first be created with the operator DEFI_FISS_XFEM [:external:ref:`U4.82.08 `], and the model (specified for the keyword MODELE) with the operator MODI_MODELE_XFEM [:external:ref:`U4.41.11 `], which is only possible in the following cases: * 3D modeling for support meshes HEXA8, PENTA6,, PYRA5, TETRA4 * models PLANet AXIpour the support meshes QUAD4et TRIA3 Keyword LIAISON_UNIF -------------------- But ~~~ Keyword factor that allows you to impose the same value (unknown) on the temperatures of a set of nodes. These nodes are defined by the mesh groups or node groups to which they belong. Syntax ~~~~~~ * for AFFE_CHAR_THER and AFFE_CHAR_THER_F .. code-block:: text LIAISON_UNIF =_F ( ♦/GROUP_MA = lgma, [l_gr_mesh] /GROUP_NO = lgno, [l_gr_node] ♦ DDL = | 'TEMP', [DEFAULT] | 'TEMP_MIL', | 'TEMP_INF', | 'TEMP_SUP', ) Operands ~~~~~~~~ .. code-block:: text ♦/GROUP_MA /GROUP_NO These operands make it possible to define a list of :math:`n` :math:`{N}_{i}` nodes whose redundancies have been eliminated (for GROUP_MA, it's mesh connectivities). .. code-block:: text ♦ DDL This operand allows you to define a list of degrees of freedom :math:`{T}_{i}(i=\mathrm{1,}r)` from :math:`r` texts taken from: 'TEMP', 'TEMP_MIL', 'TEMP_INF', 'TEMP_SUP'. The :math:`r\mathrm{\times }(n\mathrm{-}1)` resulting 'kinematic' conditions are: :math:`{T}_{i}({N}_{1})\mathrm{=}{T}_{i}({N}_{k})` for :math:`k\mathrm{\in }(\mathrm{2,}\mathrm{...},n)`, :math:`i\in (\mathrm{1,}\mathrm{...},r)` **Note:** *The components* *' TEMP_MIL ',* *' TEMP_SUP',* *' TEMP_INF 'can only be used for shell element nodes.* Keyword LIAISON_CHAMNO ---------------------- But ~~~ Keyword factor that can be used to define a linear relationship between all the temperatures present in a CHAM_NO concept. Syntax ~~~~~~ .. code-block:: text LIAISON_CHAMNO = _F (♦) CHAM_NO = field, [field] ♦ COEF_IMPO = b, [R] ) Operands ~~~~~~~~ .. code-block:: text CHAM_NO = Name of the field that is used to define the linear relationship. The related temperatures are all those present in the chamno. The coefficients to be applied to the temperatures are the values of these temperatures in the field. **Example:** Suppose we have a field with 3 nodes with the names :math:`\mathit{N01}`, :math:`\mathit{N02}` and :math:`\mathit{N03}`. Assume that the temperature values at these 3 knots in the field are 2., 5.4 and 9.1 respectively. The linear relationship which is imposed is: :math:`2.T(\mathit{NO1})+5.4T(\mathit{NO2})+9.1T(\mathit{NO3})\mathrm{=}\beta` .. code-block:: text COEF_IMPO = It is the value of the real coefficient :math:`\beta` in the second member of the linear relationship. Keyword CONVECTION ------------------ But ~~~ Keyword that can be used to take into account the term convective heat transport whose expression is :math:`\rho {C}_{p}\mathrm{.}V\mathit{grad}T`, appearing in the expression for the particulate derivative :math:`\rho {C}_{p}\frac{\mathit{dT}}{\mathit{dt}}\mathrm{:}\rho {C}_{p}\frac{\mathit{dT}}{\mathit{dt}}\mathrm{=}\rho {C}_{p}\frac{\mathrm{\partial }T}{\mathrm{\partial }t}+\rho {C}_{p}V\mathit{grad}T`. In the case of a liquid medium, :math:`V` refers to the imposed speed of the fluid particle at the current point. In the case of a mobile solid medium, :math:`V` refers to the speed of the solid. In all cases, it is assumed that the speed field is known a priory. The case of a mobile solid is quite frequent in practice. In particular, it relates to welding or surface treatment applications that involve a heat source moving in a given direction and at a given speed. The thermal problem is then studied in a frame of reference linked to the source (cf. THER_NON_LINE_MO [:ref:`U4.54.03 `]). Syntax ~~~~~~ .. code-block:: text CONVECTION = _F (♦ VITESSE = v [cham_no_sdaster]) Operand ~~~~~~~~ For AFFE_CHAR_THER and AFFE_CHAR_THER_F, VITESSE = Name of the speed field at the time the calculation is performed. This field is a cham_no concept of type cham_no_depl_r. It must have been defined on the entire model for which the calculation is carried out. Keyword SOUR_NL --------------- But ~~~ Keyword factor that can be used to apply **temperature-dependent volume sources** (2D or 3D) to a **domain** defined by one or more **volumic** cells. This type of flow is only available in command AFFE_CHAR_THER_F and is only used by commands THER_NON_LINE [:ref:`U4.54.02 `] and THER_NON_LINE_MO [:ref:`U4.54.03 `]. .. _DdeLink__11465_641831334: The values are provided by a function-like concept. The function is temperature-dependent, excluding any other parameters. Furthermore, it is necessarily a tabulated function and not a formula. Syntax ~~~~~~ .. code-block:: text SOUR_NL =_F ( ♦/TOUT = 'OUI', /GROUP_MA = lgma, [l_gr_mesh] ♦ SOUR = sf, [function] ) Operands ~~~~~~~~ This loading applies to the following mesh types and models: .. csv-table:: "**Mesh**", "**Modeling**" "HEXA8, HEXA20, HEXA27 PYRA5, PYRA13, PENTA6, PENTA15 TETRA4, TETRA10 ", "3D" "TRIA3, TRIA6, QUAD4, QUAD8, QUAD9 "," PLAN, AXIS" "HEXA8, PYRA5, PENTA6, TETRA4 ", "3D_ DIAG" "TRIA3, QUAD4 "," PLAN_DIAG, AXIS_DIAG" .. code-block:: text /♦ SOUR = s, Source value dependent on temperature and assumed to be constant on the element. Keyword EVOL_CHAR ----------------- .. code-block:: text EVOL_CHAR = evch The keyword factor EVOL_CHAR can be used to apply evol_char loads that evolve over time such as evol_char produced by LIRE_RESU [:external:ref:`U7.02.01 `] or CREA_RESU [:external:ref:`U4.44.12 `] and containing coefficient fields corresponding to either: * at a loading of type ECHANGE (see § :ref:`4.8 `): the field T_ EXTcorrespond to the parameter TEMP_EXTet the field COEF_Hcorrespond to the parameter COEF_H. * at a loading of type FLUX_REP (see § :ref:`4.5 `): the field FLUNcorrespond to the parameter of the same name.