Mentions légales du service

Skip to content
Snippets Groups Projects
demo_input_poromechanics.lua 64.79 KiB
-- Comment lines are introduced by "--".
-- In a section (i.e. within braces), all entries must be separated by a comma.

transient = {

	-- Tells which policy is used to describe time evolution.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'constant_time_step'})
	time_evolution_policy = "constant_time_step",

	-- Time at the beginning of the code (in seconds).
	-- Expected format: VALUE
	-- Constraint: v >= 0.
	init_time = 0.,

	-- Time step between two iterations, in seconds.
	-- Expected format: VALUE
	-- Constraint: v > 0.
	timeStep = 1.e-3,

	-- Maximum time, if set to zero run a static case.
	-- Expected format: VALUE
	-- Constraint: v >= 0.
	timeMax = 1.e-3

} -- transient


NumberingSubset10 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'fluid',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset10


-- NumberingSubset11 = {
--
--     -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
--     -- the possible values to choose elsewhere).
--     -- Expected format: "VALUE"
--     name = 'fluid_mass',
--
--     -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
--     -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
--     -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
--     -- displacement.
--     -- Expected format: 'true' or 'false' (without the quote)
--     do_move_mesh = false
--
-- } -- NumberingSubset11


NumberingSubset13 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'porosity',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset13


NumberingSubset14 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'solid_displacement_in_fluid_mesh',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset14


NumberingSubset15 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'fluid_mass_velocity_pressure',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset15


NumberingSubset16 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'solid_velocity_on_fluid',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset16


NumberingSubset17 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'fluid_pressure',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset17


NumberingSubset18 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'fluid_mass',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset18




NumberingSubset20 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'solid_displacement',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset20


NumberingSubset21 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'solid_velocity',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset21


NumberingSubset22 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'porosity_on_solid',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset22


NumberingSubset23 = {
    
    -- Name of the numbering subset (not really used; at the moment I just need one input parameter to ground
    -- the possible values to choose elsewhere).
    -- Expected format: "VALUE"
    name = 'fluid_mass_on_solid',
    
    -- Whether a vector defined on this numbering subset might be used to compute a movemesh. If true, a
    -- FEltSpace featuring this numbering subset will compute additional quantities to enable fast computation.
    -- This should be false for most numbering subsets, and when it's true the sole unknown involved should be a
    -- displacement.
    -- Expected format: 'true' or 'false' (without the quote)
    do_move_mesh = false
    
} -- NumberingSubset23


Unknown10 = {

	-- Name of the unknown (used for displays in output).
	-- Expected format: "VALUE"
	name = 'fluid_velocity',

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'scalar', 'vectorial'})
	nature = 'vectorial'

} -- Unknown10

Unknown11 = {

	-- Name of the unknown (used for displays in output).
	-- Expected format: "VALUE"
	name = 'fluid_pressure',

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'scalar', 'vectorial'})
	nature = 'scalar'

} -- Unknown11

Unknown12 = {

	-- Name of the unknown (used for displays in output).
	-- Expected format: "VALUE"
	name = 'fluid_mass',

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'scalar', 'vectorial'})
	nature = 'scalar'

} -- Unknown12


Unknown13 = {
    
    -- Name of the unknown (used for displays in output).
    -- Expected format: "VALUE"
    name = 'porosity',
    
    -- Index of the god of dof into which the finite element space is defined.
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'scalar', 'vectorial'})
    nature = 'scalar'
    
} -- Unknown13


Unknown20 = {

	-- Name of the unknown (used for displays in output).
	-- Expected format: "VALUE"
	name = 'solid_displacement',

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'scalar', 'vectorial'})
	nature = 'vectorial'

} -- Unknown20

Unknown21 = {

	-- Name of the unknown (used for displays in output).
	-- Expected format: "VALUE"
	name = 'solid_velocity',

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'scalar', 'vectorial'})
	nature = 'vectorial'

} -- Unknown21

-- Fluid mesh
Mesh1 = {

	-- Path of the mesh file to use.
	-- Expected format: "VALUE"
	mesh = '${HOME}/Codes/HappyHeart/Data/Mesh/poromechanics_6x6.mesh',

	-- Format of the input mesh.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'Ensight', 'Medit'})
	format = 'Medit',

	-- Highest dimension of the input mesh. This dimension might be lower than the one effectively read in the 
	-- mesh file; in which case Coords will be reduced provided all the dropped values are 0. If not, an 
	-- exception is thrown. 
	-- Expected format: VALUE
	-- Constraint: v <= 3 and v > 0
	dimension = 2,

	-- Space unit of the mesh.
	-- Expected format: VALUE
	space_unit = 1.

} -- Mesh1


-- Solid mesh
-- Must be the same as mesh1 for poromechanics model!
Mesh2 = {

	-- Path of the mesh file to use.
	-- Expected format: "VALUE"
	mesh = '${HOME}/Codes/HappyHeart/Data/Mesh/poromechanics_6x6.mesh',

	-- Format of the input mesh.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'Ensight', 'Medit'})
	format = "Medit",

	-- Highest dimension of the input mesh. This dimension might be lower than the one effectively read in the 
	-- mesh file; in which case Coords will be reduced provided all the dropped values are 0. If not, an 
	-- exception is thrown. 
	-- Expected format: VALUE
	-- Constraint: v <= 3 and v > 0
	dimension = 2,

	-- Space unit of the mesh.
	-- Expected format: VALUE
	space_unit = 1.

} -- Mesh2


Domain10 = {

	-- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be 
	-- left empty if domain not limited to one mesh; at most one value is expected here. 
	-- Expected format: {VALUE1, VALUE2, ...}
	mesh_index = { 1 },

	-- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon 
	-- dimensions. 
	-- Expected format: {VALUE1, VALUE2, ...}
	-- Constraint: ops_in(v, {0, 1, 2, 3})
	dimension_list = { 2 },

	-- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh 
	-- labels. This parameter does not make sense if no mesh is defined for the domain. 
	-- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = {},

	-- List of geometric element types considered in the domain. Might be left empty if no restriction upon 
	-- these. No constraint is applied at Ops level, as some geometric element types could be added after 
	-- generation of current input parameter file. Current list is below; if an incorrect value is put there it 
	-- will be detected a bit later when the domain object is built.
 	-- The known types when this file was generated are: 
 	-- . Point1
 	-- . Segment2, Segment3
 	-- . Triangle3, Triangle6
 	-- . Quadrangle4, Quadrangle8, Quadrangle9
 	-- . Tetrahedron4, Tetrahedron10
 	-- . Hexahedron8, Hexahedron20, Hexahedron27. 
	-- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}

} -- Domain10



-- Non homogeneous Dirichlet
Domain11 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 1 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { 1 },
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 1, 3 },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain11

-- Inlet border
Domain12 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 1 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { 1 },
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 4 },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain12


-- Robin interface
Domain13 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 1 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { },
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 1, 3  },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain13



Domain20 = {

    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 2 },

    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { 2 },


    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = {},

    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}

} -- Domain20


-- Inlet border for solid mesh.
Domain21 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 2 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { 1 },
    
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 4 },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain21



Domain22 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 2 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { },
    
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 4 },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain22


Domain23 = {
    
    -- Index of the geometric mesh upon which the domain is defined (as defined in the present file). Might be
    -- left empty if domain not limited to one mesh; at most one value is expected here.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_index = { 2 },
    
    -- List of dimensions encompassed by the domain. Might be left empty if no restriction at all upon
    -- dimensions.
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: ops_in(v, {0, 1, 2, 3})
    dimension_list = { },
    
    
    -- List of mesh labels encompassed by the domain. Might be left empty if no restriction at all upon mesh
    -- labels. This parameter does not make sense if no mesh is defined for the domain.
    -- Expected format: {VALUE1, VALUE2, ...}
    mesh_label_list = { 1 },
    
    -- List of geometric element types considered in the domain. Might be left empty if no restriction upon
    -- these. No constraint is applied at Ops level, as some geometric element types could be added after
    -- generation of current input parameter file. Current list is below; if an incorrect value is put there it
    -- will be detected a bit later when the domain object is built.
    -- The known types when this file was generated are:
    -- . Point1
    -- . Segment2, Segment3
    -- . Triangle3, Triangle6
    -- . Quadrangle4, Quadrangle8, Quadrangle9
    -- . Tetrahedron4, Tetrahedron10
    -- . Hexahedron8, Hexahedron20, Hexahedron27.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    geometric_element_type_list = {}
    
} -- Domain23


EssentialBoundaryCondition10 = {

    -- Name of the boundary condition (must be unique).
    -- Expected format: "VALUE"
    name = 'fluid_non_homogeneous_on_interface',

    -- Comp1, Comp2 or Comp3
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'Comp1', 'Comp2', 'Comp3', 'Comp12', 'Comp23', 'Comp13', 'Comp123'})
    component = 'Comp12',

    -- Name of the unknown addressed by the boundary condition.
    -- Expected format: "VALUE"
    unknown = 'fluid_velocity',

    -- Values at each of the relevant component.
    -- Expected format: {VALUE1, VALUE2, ...}
    value = { 0., 0. },

    -- Index of the domain onto which essential boundary condition is defined.
    -- Expected format: VALUE
    domain_index = 11,

    -- Whether the values of the boundary condition may vary over time.
    -- Expected format: 'true' or 'false' (without the quote)
    is_mutable = true,

    -- Whether a dof of this boundary condition may also belong to another one. This highlights an ill-defined
    -- model in most cases, but I nonetheless need it for FSI/ALE.
    -- Expected format: 'true' or 'false' (without the quote)
    may_overlap = true

} -- EssentialBoundaryCondition10


EssentialBoundaryCondition11 = {
    
    -- Name of the boundary condition (must be unique).
    -- Expected format: "VALUE"
    name = 'fluid_robin_interface',
    
    -- Comp1, Comp2 or Comp3
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'Comp1', 'Comp2', 'Comp3', 'Comp12', 'Comp23', 'Comp13', 'Comp123'})
    component = 'Comp12',
    
    -- Name of the unknown addressed by the boundary condition.
    -- Expected format: "VALUE"
    unknown = 'fluid_velocity',
    
    -- Values at each of the relevant component.
    -- Expected format: {VALUE1, VALUE2, ...}
    value = { 0., 0. },
    
    -- Index of the domain onto which essential boundary condition is defined.
    -- Expected format: VALUE
    domain_index = 13,
    
    -- Whether the values of the boundary condition may vary over time.
    -- Expected format: 'true' or 'false' (without the quote)
    is_mutable = false,
    
    -- Whether a dof of this boundary condition may also belong to another one. This highlights an ill-defined
    -- model in most cases, but I nonetheless need it for FSI/ALE.
    -- Expected format: 'true' or 'false' (without the quote)
    may_overlap = true
    
} -- EssentialBoundaryCondition11


EssentialBoundaryCondition12 = {
    
    -- Name of the boundary condition (must be unique).
    -- Expected format: "VALUE"
    name = 'fluid_robin_interface_dH',
    
    -- Comp1, Comp2 or Comp3
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'Comp1', 'Comp2', 'Comp3', 'Comp12', 'Comp23', 'Comp13', 'Comp123'})
    component = 'Comp12',
    
    -- Name of the unknown addressed by the boundary condition.
    -- Expected format: "VALUE"
    unknown = 'fluid_velocity',
    
    -- Values at each of the relevant component.
    -- Expected format: {VALUE1, VALUE2, ...}
    value = { 0., 0. },
    
    -- Index of the domain onto which essential boundary condition is defined.
    -- Expected format: VALUE
    domain_index = 13,
    
    -- Whether the values of the boundary condition may vary over time.
    -- Expected format: 'true' or 'false' (without the quote)
    is_mutable = true,
    
    -- Whether a dof of this boundary condition may also belong to another one. This highlights an ill-defined
    -- model in most cases, but I nonetheless need it for FSI/ALE.
    -- Expected format: 'true' or 'false' (without the quote)
    may_overlap = false
    
} -- EssentialBoundaryCondition12



-- Radial on solid
EssentialBoundaryCondition20= {
    
    -- Name of the boundary condition (must be unique).
    -- Expected format: "VALUE"
    name = 'solid_radial',
    
    -- Comp1, Comp2 or Comp3
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'Comp1', 'Comp2', 'Comp3', 'Comp12', 'Comp23', 'Comp13', 'Comp123'})
    component = 'Comp1',
    
    -- Name of the unknown addressed by the boundary condition.
    -- Expected format: "VALUE"
    unknown = 'solid_displacement',
    
    -- Values at each of the relevant component.
    -- Expected format: {VALUE1, VALUE2, ...}
    value = { 0. },
    
    -- Index of the domain onto which essential boundary condition is defined.
    -- Expected format: VALUE
    domain_index = 22,
    
    -- Whether the values of the boundary condition may vary over time.
    -- Expected format: 'true' or 'false' (without the quote)
    is_mutable = false,
    
    -- Whether a dof of this boundary condition may also belong to another one. This highlights an ill-defined
    -- model in most cases, but I nonetheless need it for FSI/ALE.
    -- Expected format: 'true' or 'false' (without the quote)
    may_overlap = false
    
} -- EssentialBoundaryCondition20


EssentialBoundaryCondition21= {
    
    -- Name of the boundary condition (must be unique).
    -- Expected format: "VALUE"
    name = 'solid_vertical',
    
    -- Comp1, Comp2 or Comp3
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'Comp1', 'Comp2', 'Comp3', 'Comp12', 'Comp23', 'Comp13', 'Comp123'})
    component = 'Comp2',
    
    -- Name of the unknown addressed by the boundary condition.
    -- Expected format: "VALUE"
    unknown = 'solid_displacement',
    
    -- Values at each of the relevant component.
    -- Expected format: {VALUE1, VALUE2, ...}
    value = { 0. },
    
    -- Index of the domain onto which essential boundary condition is defined.
    -- Expected format: VALUE
    domain_index = 23,
    
    -- Whether the values of the boundary condition may vary over time.
    -- Expected format: 'true' or 'false' (without the quote)
    is_mutable = false,
    
    -- Whether a dof of this boundary condition may also belong to another one. This highlights an ill-defined
    -- model in most cases, but I nonetheless need it for FSI/ALE.
    -- Expected format: 'true' or 'false' (without the quote)
    may_overlap = false
    
} -- EssentialBoundaryCondition21


FiniteElementSpace10 = {

	-- Index of the god of dof into which the finite element space is defined.
	-- Expected format: VALUE
	god_of_dof_index = 1,
	-- Index of the domain onto which the finite element space is defined. This domain must be unidimensional.
	-- Expected format: VALUE
	domain_index = 10,

	-- List of all unknowns defined in the finite element space. Unknowns here must be defined in this file as 
	-- an 'Unknown' block; expected name/identifier is the name given there. 
	-- Expected format: {"VALUE1", "VALUE2", ...}
    unknown_list = { 'fluid_velocity', 'porosity', 'solid_displacement', 'solid_velocity', 'fluid_pressure', 'fluid_mass'},

	-- List of the shape function to use for each unknown;
	-- Expected format: {"VALUE1", "VALUE2", ...}
    shape_function_list = { 'P1b', 'P1', 'P1', 'P1', 'P1', 'P1' },

	-- List of the numbering subset to use for each unknown;
	-- Expected format: {VALUE1, VALUE2, ...}
	numbering_subset_list = { 10, 13, 14, 16, 17, 18 }

} -- FiniteElementSpace10



-- FiniteElementSpace11 -- Inlet border
FiniteElementSpace11 = {
    -- Index of the god of dof into which the finite element space is defined.
    -- Expected format: VALUE
    god_of_dof_index = 1,
    
    -- Index of the domain onto which the finite element space is defined. This domain must be unidimensional.
    -- Expected format: VALUE
    domain_index = 12,
    
    -- List of all unknowns defined in the finite element space. Unknowns here must be defined in this file as
    -- an 'Unknown' block; expected name/identifier is the name given there.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    unknown_list = { 'fluid_velocity', 'porosity'},
    
    -- List of the shape function to use for each unknown;
    -- Expected format: {"VALUE1", "VALUE2", ...}
    --    shape_function_list = { 'P2', 'P1' },
    shape_function_list = { 'P1', 'P1' },
    
    -- List of the numbering subset to use for each unknown;
    -- Expected format: {VALUE1, VALUE2, ...}
    numbering_subset_list = { 15, 13 }
}


-- FiniteElementSpace12 -- Monolithic
FiniteElementSpace12 = {
    -- Index of the god of dof into which the finite element space is defined.
    -- Expected format: VALUE
    god_of_dof_index = 1,
    
    -- Index of the domain onto which the finite element space is defined. This domain must be unidimensional.
    -- Expected format: VALUE
    domain_index = 10,
    
    -- List of all unknowns defined in the finite element space. Unknowns here must be defined in this file as
    -- an 'Unknown' block; expected name/identifier is the name given there.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    unknown_list = { 'fluid_mass', 'fluid_pressure', 'fluid_velocity', 'porosity' },
    
    -- List of the shape function to use for each unknown;
    -- Expected format: {"VALUE1", "VALUE2", ...}
    --    shape_function_list = { 'P2', 'P1' },
    shape_function_list = { 'P1', 'P1', 'P1b', 'P1' },
    
    -- List of the numbering subset to use for each unknown;
    -- Expected format: {VALUE1, VALUE2, ...}
    numbering_subset_list = { 15, 15, 15, 13 }
}




FiniteElementSpace20 = {

    -- Index of the god of dof into which the finite element space is defined.
    -- Expected format: VALUE
    god_of_dof_index = 2,

    -- Index of the domain onto which the finite element space is defined. This domain must be unidimensional.
    -- Expected format: VALUE
    domain_index = 20,

    -- List of all unknowns defined in the finite element space. Unknowns here must be defined in this file as
    -- an 'Unknown' block; expected name/identifier is the name given there.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    unknown_list = { 'solid_displacement', 'solid_velocity', 'porosity', 'fluid_mass' },

    -- List of the shape function to use for each unknown;
    -- Expected format: {"VALUE1", "VALUE2", ...}
    shape_function_list = { 'P1', 'P1', 'P1', 'P1' },

    -- List of the numbering subset to use for each unknown;
    -- Expected format: {VALUE1, VALUE2, ...}
    numbering_subset_list = { 20, 21, 22, 23 }

} -- FiniteElementSpace20



FiniteElementSpace21 = {
    
    -- Index of the god of dof into which the finite element space is defined.
    -- Expected format: VALUE
    god_of_dof_index = 2,
    
    -- Index of the domain onto which the finite element space is defined. This domain must be unidimensional.
    -- Expected format: VALUE
    domain_index = 21,
    
    -- List of all unknowns defined in the finite element space. Unknowns here must be defined in this file as
    -- an 'Unknown' block; expected name/identifier is the name given there.
    -- Expected format: {"VALUE1", "VALUE2", ...}
    unknown_list = { 'solid_displacement', 'fluid_mass' },
    
    -- List of the shape function to use for each unknown;
    -- Expected format: {"VALUE1", "VALUE2", ...}
    shape_function_list = { 'P1', 'P1' },
    
    -- List of the numbering subset to use for each unknown;
    -- Expected format: {VALUE1, VALUE2, ...}
    numbering_subset_list = { 20, 23 }
    
} -- FiniteElementSpace20





Petsc1 = {

	-- Absolute tolerance
	-- Expected format: VALUE
	-- Constraint: v > 0.
	absoluteTolerance = 1e-10,

	-- gmresStart
	-- Expected format: VALUE
	-- Constraint: v >= 0
	gmresRestart = 200,

	-- Maximum iteration
	-- Expected format: VALUE
	-- Constraint: v > 0
	maxIteration = 1000,

	-- Preconditioner to use. Must be lu for any direct solver.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, {'lu', 'none'})
	preconditioner = "lu",

	-- Relative tolerance
	-- Expected format: VALUE
	-- Constraint: v > 0.
	relativeTolerance = 1e-6,
    
    
    -- Step size tolerance
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v > 0.
    stepSizeTolerance = 1e-8,

	-- Solver to use.
	-- Expected format: "VALUE"
	-- Constraint: ops_in(v, { 'Mumps', 'Umfpack', 'Gmres' })
	solver = "Mumps"

} -- Petsc1

Petsc2 = {
    
    -- Absolute tolerance
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v > 0.
    absoluteTolerance = 1.e-10,
    
    -- gmresStart
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v >= 0
    gmresRestart = 100,
    
    -- Maximum iteration
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v > 0
    maxIteration = 1000,
    
    -- List of preconditioner: { none jacobi sor lu bjacobi ilu asm cholesky }.
    -- To use mumps:
    -- preconditioner = lu
    -- Expected format: {"VALUE1", "VALUE2", ...}
    -- Constraint: ops_in(v, 'lu')
    preconditioner = 'none',
    
    -- Relative tolerance
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v > 0.
    relativeTolerance = 1.e-4,
    
    -- Step size tolerance
    -- Expected format: {VALUE1, VALUE2, ...}
    -- Constraint: v > 0.
    stepSizeTolerance = 1e-8,
    
    -- List of solver: { chebychev cg gmres preonly bicg python };
    -- Expected format: {"VALUE1", "VALUE2", ...}
    -- Constraint: ops_in(v, {'Mumps', 'Umfpack', 'Gmres'})
    solver = 'Gmres',
    
} -- Petsc2


Result = {

	-- Directory in which all the results will be written.
	-- Expected format: "VALUE"
    output_directory = '${HAPPY_HEART_RESULT_DIR}/Poromechanics',
    
    -- Enables to skip some printing in the console. Can be used to WriteSolution every n time.
    -- Expected format: VALUE
    display_value = 1


} -- Result



Fluid = {
    
    Density = {
        
        -- How is given the volumic mass (as a constant, as a Lua function, per quadrature point, etc...)
        -- Expected format: "VALUE"
        -- Constraint: ops_in(v, {'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
        nature = 'constant',
        
        -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: VALUE
        scalar_value = 1000.,
        
        -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: Function in Lua language, for instance:
        -- 		-- function(arg1, arg2, arg3)
        -- return arg1 + arg2 -
        -- arg3
        -- end
        -- sin, cos and tan require a 'math.'
        -- preffix.
        -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
        -- content is not interpreted by Ops until an actual use of the underlying function.
        lua_function = None,
        
        -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
        -- domains given here must not intersect.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_id = {},
        
        -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_value = {}
        
    }, -- Density
    
    
    Viscosity = {
        
        -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
        -- Expected format: "VALUE"
        -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
        nature = 'constant',
        
        -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: VALUE
        scalar_value = 0.035,
        
        -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: Function in Lua language, for instance:
        -- 		-- function(arg1, arg2, arg3)
        -- return arg1 + arg2 -
        -- arg3
        -- end
        -- sin, cos and tan require a 'math.'
        -- preffix.
        -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
        -- content is not interpreted by Ops until an actual use of the underlying function.
        lua_function = none,
        
        -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
        -- domains given here must not intersect.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_id = {},
        
        -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_value = {}
        
    }, -- Viscosity
    
} -- Fluid


    
Solid = {
    
    -- For 2D operators, which approximation to use.
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'irrelevant', 'plane_strain', 'plane_stress'}),
    PlaneStressStrain = "plane_strain",


    HyperelasticBulk = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
      nature = 'constant',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      scalar_value = 2.e4,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {}
      
    }, -- HyperelasticBulk

    Kappa1 = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
      nature = "ignore",
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 2.e3,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- Kappa1

    Kappa2 = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
      nature = "ignore",
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 33.,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- Kappa2

    PoissonRatio = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
      nature = 'ignore',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 0.4048012986607561,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- PoissonRatio

    YoungModulus = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
      nature = 'ignore',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 11423.84416070927,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- YoungModulus


    LameLambda = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {"ignore", "constant", "lua_function", "at_quadrature_point", "piecewise_constant_by_domain"})
      nature = 'constant',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 17289.333333333332,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- LameLambda


    LameMu = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {"ignore", "constant", "lua_function", "at_quadrature_point", "piecewise_constant_by_domain"})
      nature = 'constant',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 4066.,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = {},
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = {},
      
    }, -- LameMu


    VolumicMass = {
      
      -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
      -- Expected format: "VALUE"
      -- Constraint: ops_in(v, {"ignore", "constant", "lua_function", "at_quadrature_point", "piecewise_constant_by_domain"})
      nature = 'constant',
      
      -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: VALUE
      -- Constraint: v > 0.
      scalar_value = 1.e3,
      
      -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
      -- 'at_quadrature_point'; irrelevant otherwise).
      -- Expected format: Function in Lua language, for instance:
      -- 		-- function(arg1, arg2, arg3)
      -- return arg1 + arg2 -
      -- arg3
      -- end
      -- sin, cos and tan require a 'math.'
      -- preffix.
      -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
      -- content is not interpreted by Ops until an actual use of the underlying function.
      lua_function = none,
      
      -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
      -- domains given here must not intersect.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_id = { },
      
      -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
      -- Expected format: {VALUE1, VALUE2, ...}
      piecewise_constant_domain_value = { }
      
    }, -- VolumicMass
    
    
    Viscosity = {
        
        -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...)
        -- Expected format: "VALUE"
        -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
        nature = 'ignore',
        
        -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: VALUE
        -- Constraint: v > 0.
        scalar_value = 1000.,
        
        -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
        -- 'at_quadrature_point'; irrelevant otherwise).
        -- Expected format: Function in Lua language, for instance:
        -- 		-- function(arg1, arg2, arg3)
        -- return arg1 + arg2 -
        -- arg3
        -- end
        -- sin, cos and tan require a 'math.'
        -- preffix.
        -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
        -- content is not interpreted by Ops until an actual use of the underlying function.
        lua_function = none,
        
        -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
        -- domains given here must not intersect.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_id = {},
        
        -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
        -- Expected format: {VALUE1, VALUE2, ...}
        piecewise_constant_domain_value = {},
        
    }, -- Viscosity
  
  
} -- Solid
  
  
bulk_solid = {
    
    -- How is given the volumic mass (as a constant, as a Lua function, per quadrature point, etc...)
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'constant', 'lua_function', 'at_quadrature_point', 'piecewise_constant_by_domain'})
    nature = 'constant',
    
    -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Expected format: VALUE
    scalar_value = 2.e5,
    
    -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Expected format: Function in Lua language, for instance:
    -- 	-- function(arg1, arg2, arg3)
    -- return arg1 + arg2 -
    -- arg3
    -- end
    -- sin, cos and tan require a 'math.'
    -- preffix.
    -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
    -- content is not interpreted by Ops until an actual use of the underlying function.
    lua_function = none,
    
    -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
    -- domains given here must not intersect.
    -- Expected format: {VALUE1, VALUE2, ...}
    piecewise_constant_domain_id = {},
    
    -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
    -- Expected format: {VALUE1, VALUE2, ...}
    piecewise_constant_domain_value = {}
    
} -- bulk_solid



-- inlet pressure
TransientSource1 = {
    
    -- How is given the transient source value (as a constant, as a Lua function, per quadrature point, etc...)
    -- Expected format: {"VALUE1", "VALUE2", ...}
    -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function'})
    nature = {"constant", "constant", "constant"},
    
    -- Value of the transient source in the case nature is 'constant'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Expected format: {VALUE1, VALUE2, ...}
    scalar_value = { 4.e-3 , 0., 0.},
    
    -- Value of the transient source  in the case nature is 'lua_function'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Function expects as arguments global coordinates (coordinates in the mesh).
    -- Expected format: Function in Lua language, for instance:
    -- 	-- function(arg1, arg2, arg3)
    -- return arg1 + arg2 -
    -- arg3
    -- end
    -- sin, cos and tan require a 'math.'
    -- preffix.
    -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
    -- content is not interpreted by Ops until an actual use of the underlying function.
    lua_function_x = none,
    
    -- Value of the transient source  in the case nature is 'lua_function'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Function expects as arguments global coordinates (coordinates in the mesh).
    -- Expected format: Function in Lua language, for instance:
    -- 	-- function(arg1, arg2, arg3)
    -- return arg1 + arg2 -
    -- arg3
    -- end
    -- sin, cos and tan require a 'math.'
    -- preffix.
    -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
    -- content is not interpreted by Ops until an actual use of the underlying function.
    lua_function_y = none,
    
    -- Value of the transient source  in the case nature is 'lua_function'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Function expects as arguments global coordinates (coordinates in the mesh).
    -- Expected format: Function in Lua language, for instance:
    -- 	-- function(arg1, arg2, arg3)
    -- return arg1 + arg2 -
    -- arg3
    -- end
    -- sin, cos and tan require a 'math.'
    -- preffix.
    -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
    -- content is not interpreted by Ops until an actual use of the underlying function. 
    lua_function_z = none
    
} -- TransientSource1

-- Initial value of porosity at each dof.
-- Expected format: VALUE
porosity = 0.1


-- Fluid/porosity
InitVertexMatchingInterpolator10 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 10,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 13
    
} -- InitVertexMatchingInterpolator10


-- Solid/porosity
InitVertexMatchingInterpolator20 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 20,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 22
    
} -- InitVertexMatchingInterpolator20


-- Solid velocity on fluid (P1)
InitVertexMatchingInterpolator11 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 10,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 16
    
} -- InitVertexMatchingInterpolator11



-- Solid/velocity
InitVertexMatchingInterpolator21 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 20,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 21
    
} -- InitVertexMatchingInterpolator21


-- Fluid/mass
InitVertexMatchingInterpolator12 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 10,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 18
    
} -- InitVertexMatchingInterpolator12


-- Solid/mass
InitVertexMatchingInterpolator22 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 20,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 23
    
} -- InitVertexMatchingInterpolator22

-- Fluid/pressure
InitVertexMatchingInterpolator13 = {
    
    -- Finite element space for which the dofs index will be associated to each vertex.
    -- Expected format: VALUE
    finite_element_space = 10,
    
    -- Numbering subsetfor which the dofs index will be associated to each vertex.
    -- Expected format: "VALUE"
    numbering_subset = 17
    
} -- InitVertexMatchingInterpolator12




PenalizationPorosity = {
    
    -- How is given the parameter (as a constant, as a Lua function, per quadrature point, etc...). Choose
    -- "ignore" if you do not want this parameter (in this case it will stay at nullptr).
    -- Expected format: "VALUE"
    -- Constraint: ops_in(v, {'ignore', 'constant', 'lua_function','at_quadrature_point','piecewise_constant_by_domain'})
    nature = 'constant',
    
    -- Value of the volumic mass in the case nature is 'constant'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Expected format: VALUE
    scalar_value = 0.,
    
    -- Value of the volumic mass in the case nature is 'lua_function'(and also initial value if nature is
    -- 'at_quadrature_point'; irrelevant otherwise).
    -- Expected format: Function in Lua language, for instance:
    -- 	-- function(arg1, arg2, arg3)
    -- return arg1 + arg2 -
    -- arg3
    -- end
    -- sin, cos and tan require a 'math.'
    -- preffix.
    -- If you do not wish to provide one, put anything you want (e.g. 'none'): the
    -- content is not interpreted by Ops until an actual use of the underlying function.
    lua_function = none,
    
    -- Domain indices of the parameter in the case nature is 'piecewise_constant_by_domain'. The various
    -- domains given here must not intersect.
    -- Expected format: {VALUE1, VALUE2, ...}
    piecewise_constant_domain_id = {},
    
    -- Value of the parameter in the case nature is 'piecewise_constant_by_domain'.
    -- Expected format: {VALUE1, VALUE2, ...}
    piecewise_constant_domain_value = {}
    
} -- PenalizationPorosity

-- File that gives for each vertex on the first mesh on the interface the index of the equivalent vertex in
-- the second mesh.
-- Expected format: "VALUE"
interpolation_file = "${HOME}/Codes/HappyHeart/Data/Interpolation/Poromechanics/Identity_6.hhdata"

-- Internal friction.
-- Expected format: VALUE
internal_friction = 1.e7

-- Initial porosity value.
-- Expected format: VALUE
initial_porosity_value = 0.1