OGS
ProcessLib::RichardsMechanics Namespace Reference

Namespaces

 detail
 

Classes

struct  MicroPorosityStateSpace
 
struct  MicroPorosityParameters
 
struct  IntegrationPointData
 
struct  LocalAssemblerInterface
 
class  LocalDataInitializer
 
struct  SecondaryData
 
class  RichardsMechanicsLocalAssembler
 
class  RichardsMechanicsProcess
 
struct  RichardsMechanicsProcessData
 

Functions

template<int DisplacementDim>
std::ostream & operator<< (std::ostream &os, MicroPorosityStateSpace< DisplacementDim > const &state)
 
template<int DisplacementDim>
MicroPorosityStateSpace< DisplacementDim > computeMicroPorosity (MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &I_2_C_el_inverse, double const rho_LR_m, double const mu_LR, MicroPorosityParameters const &micro_porosity_parameters, double const alpha_B, double const phi, double const p_L, double const p_L_m_prev, MaterialPropertyLib::VariableArray const &, double const S_L_m_prev, double const phi_m_prev, ParameterLib::SpatialPosition const pos, double const t, double const dt, MaterialPropertyLib::Property const &saturation_micro, MaterialPropertyLib::Property const &swelling_stress_rate)
 
template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void createLocalAssemblers (const unsigned, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
 
void checkMPLProperties (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
 
template<int DisplacementDim>
std::unique_ptr< ProcesscreateRichardsMechanicsProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
 
template std::unique_ptr< ProcesscreateRichardsMechanicsProcess< 2 > (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
 
template std::unique_ptr< ProcesscreateRichardsMechanicsProcess< 3 > (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, std::optional< ParameterLib::CoordinateSystem > const &local_coordinate_system, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
 
template<int DisplacementDim, typename IPData >
void updateSwellingStressAndVolumetricStrain (IPData &ip_data, MaterialPropertyLib::Medium const &medium, MaterialPropertyLib::Phase const &solid_phase, MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > const &C_el, double const rho_LR, double const mu, std::optional< MicroPorosityParameters > micro_porosity_parameters, double const alpha, double const phi, double const p_cap_ip, MPL::VariableArray &variables, MPL::VariableArray &variables_prev, ParameterLib::SpatialPosition const &x_position, double const t, double const dt)
 

Function Documentation

◆ checkMPLProperties()

void ProcessLib::RichardsMechanics::checkMPLProperties ( std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &  media)

Definition at line 31 of file CreateRichardsMechanicsProcess.cpp.

33 {
34  std::array const required_medium_properties = {
41  std::array const required_liquid_properties = {
43  std::array const required_solid_properties = {MaterialPropertyLib::density};
44 
45  for (auto const& m : media)
46  {
47  checkRequiredProperties(*m.second, required_medium_properties);
48  checkRequiredProperties(m.second->phase("AqueousLiquid"),
49  required_liquid_properties);
50  checkRequiredProperties(m.second->phase("Solid"),
51  required_solid_properties);
52  }
53 }
void checkRequiredProperties(Component const &c, Container const &required_properties)
Definition: Component.h:96

References MaterialPropertyLib::biot_coefficient, MaterialPropertyLib::bishops_effective_stress, MaterialPropertyLib::checkRequiredProperties(), MaterialPropertyLib::density, MaterialPropertyLib::porosity, MaterialPropertyLib::reference_temperature, MaterialPropertyLib::relative_permeability, MaterialPropertyLib::saturation, and MaterialPropertyLib::viscosity.

Referenced by createRichardsMechanicsProcess().

◆ computeMicroPorosity()

template<int DisplacementDim>
MicroPorosityStateSpace<DisplacementDim> ProcessLib::RichardsMechanics::computeMicroPorosity ( MathLib::KelvinVector::KelvinVectorType< DisplacementDim > const &  I_2_C_el_inverse,
double const  rho_LR_m,
double const  mu_LR,
MicroPorosityParameters const &  micro_porosity_parameters,
double const  alpha_B,
double const  phi,
double const  p_L,
double const  p_L_m_prev,
MaterialPropertyLib::VariableArray const &  ,
double const  S_L_m_prev,
double const  phi_m_prev,
ParameterLib::SpatialPosition const  pos,
double const  t,
double const  dt,
MaterialPropertyLib::Property const &  saturation_micro,
MaterialPropertyLib::Property const &  swelling_stress_rate 
)

Definition at line 63 of file ComputeMicroPorosity.h.

76 {
77  namespace MPL = MaterialPropertyLib;
78  static constexpr int kelvin_vector_size =
80  // phi_m, e_sw, p_L_m, sigma_sw
81  static constexpr int nls_size = 1 + 1 + 1 + kelvin_vector_size;
82 
83  static constexpr int i_phi_m = 0;
84  static constexpr int i_e_sw = 1;
85  static constexpr int i_p_L_m = 2;
86  static constexpr int i_sigma_sw = 3;
87 
88  using ResidualVectorType = Eigen::Matrix<double, nls_size, 1>;
89  using JacobianMatrix =
90  Eigen::Matrix<double, nls_size, nls_size, Eigen::RowMajor>;
91 
92  Eigen::FullPivLU<Eigen::Matrix<double, nls_size, nls_size, Eigen::RowMajor>>
93  linear_solver;
94 
95  JacobianMatrix jacobian;
96 
97  // Agglomerated solution vector construction.
98  ResidualVectorType solution = ResidualVectorType::Zero();
99 
100  if (p_L >= 0 && p_L_m_prev >= 0)
101  {
102  return {solution[i_phi_m], solution[i_e_sw], solution[i_p_L_m],
103  solution.template segment<kelvin_vector_size>(i_sigma_sw)};
104  }
105 
106  double const alpha_bar =
107  micro_porosity_parameters.mass_exchange_coefficient;
108 
109  auto const update_residual = [&](ResidualVectorType& residual)
110  {
111  double const delta_phi_m = solution[i_phi_m];
112  double const delta_e_sw = solution[i_e_sw];
113  auto const& delta_sigma_sw =
114  solution.template segment<kelvin_vector_size>(i_sigma_sw);
115  double const delta_p_L_m = solution[i_p_L_m];
116 
117  double const phi_m = phi_m_prev + delta_phi_m;
118  double const p_L_m = p_L_m_prev + delta_p_L_m;
119  MPL::VariableArray variables_prev;
120  variables_prev[static_cast<int>(MPL::Variable::capillary_pressure)] =
121  -p_L_m_prev;
122  variables_prev[static_cast<int>(MPL::Variable::liquid_saturation)] =
123  S_L_m_prev;
124 
125  MPL::VariableArray variables;
126  variables[static_cast<int>(MPL::Variable::capillary_pressure)] = -p_L_m;
127 
128  double const S_L_m =
129  saturation_micro.template value<double>(variables, pos, t, dt);
130  variables[static_cast<int>(MPL::Variable::liquid_saturation)] = S_L_m;
131  double const delta_S_L_m = S_L_m - S_L_m_prev;
132 
133  auto const sigma_sw_dot =
134  MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
135  swelling_stress_rate.template value<Eigen::Matrix3d>(
136  variables, variables_prev, pos, t, dt));
137 
138  residual[i_phi_m] = delta_phi_m - (alpha_B - phi) * delta_e_sw;
139  residual[i_e_sw] = delta_e_sw + I_2_C_el_inverse.dot(delta_sigma_sw);
140  residual.template segment<kelvin_vector_size>(i_sigma_sw).noalias() =
141  delta_sigma_sw - sigma_sw_dot * dt;
142 
143  residual[i_p_L_m] =
144  rho_LR_m *
145  (phi_m * delta_S_L_m - (alpha_B - phi) * S_L_m * delta_e_sw) +
146  phi_m * S_L_m * rho_LR_m * delta_e_sw -
147  micro_porosity_parameters.mass_exchange_coefficient / mu_LR *
148  (p_L - p_L_m) * dt;
149  };
150 
151  auto const update_jacobian = [&](JacobianMatrix& jacobian)
152  {
153  jacobian = JacobianMatrix::Identity();
154 
155  double const delta_phi_m = solution[i_phi_m];
156  double const delta_e_sw = solution[i_e_sw];
157  double const delta_p_L_m = solution[i_p_L_m];
158 
159  double const phi_m = phi_m_prev + delta_phi_m;
160  double const p_L_m = p_L_m_prev + delta_p_L_m;
161  MPL::VariableArray variables_prev;
162  variables_prev[static_cast<int>(MPL::Variable::capillary_pressure)] =
163  -p_L_m_prev;
164  MPL::VariableArray variables;
165  variables[static_cast<int>(MPL::Variable::capillary_pressure)] = -p_L_m;
166 
167  double const S_L_m =
168  saturation_micro.template value<double>(variables, pos, t, dt);
169  variables_prev[static_cast<int>(MPL::Variable::liquid_saturation)] =
170  S_L_m_prev;
171  variables[static_cast<int>(MPL::Variable::liquid_saturation)] = S_L_m;
172  double const delta_S_L_m = S_L_m - S_L_m_prev;
173 
174  double const dS_L_m_dp_cap_m = saturation_micro.template dValue<double>(
175  variables, MPL::Variable::capillary_pressure, pos, t, dt);
176  auto const dsigma_sw_dS_L_m =
177  MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
178  swelling_stress_rate.template dValue<Eigen::Matrix3d>(
179  variables, variables_prev, MPL::Variable::liquid_saturation,
180  pos, t, dt));
181 
182  jacobian(i_phi_m, i_e_sw) = -(alpha_B - phi);
183 
184  jacobian.template block<1, kelvin_vector_size>(i_e_sw, i_sigma_sw) =
185  I_2_C_el_inverse.transpose();
186 
187  jacobian.template block<kelvin_vector_size, 1>(i_sigma_sw, i_p_L_m) =
188  -dsigma_sw_dS_L_m * dS_L_m_dp_cap_m;
189 
190  jacobian(i_p_L_m, i_phi_m) =
191  rho_LR_m * (delta_S_L_m + S_L_m * delta_e_sw);
192 
193  jacobian(i_p_L_m, i_e_sw) = -rho_LR_m * S_L_m * (alpha_B - phi - phi_m);
194 
195  jacobian(i_p_L_m, i_p_L_m) =
196  alpha_bar / mu_LR * dt -
197  rho_LR_m * (phi_m - (alpha_B - phi - phi_m) * delta_e_sw) *
198  dS_L_m_dp_cap_m;
199  };
200 
201  auto const update_solution = [&](ResidualVectorType const& increment)
202  { solution += increment; };
203 
204  auto newton_solver =
205  NumLib::NewtonRaphson<decltype(linear_solver), JacobianMatrix,
206  decltype(update_jacobian), ResidualVectorType,
207  decltype(update_residual),
208  decltype(update_solution)>(
209  linear_solver, update_jacobian, update_residual, update_solution,
210  micro_porosity_parameters.nonlinear_solver_parameters);
211 
212  auto const success_iterations = newton_solver.solve(jacobian);
213 
214  if (!success_iterations)
215  {
216  OGS_FATAL(
217  "Could not find solution for local double structure nonlinear "
218  "problem.");
219  }
220 
221  return {solution[i_phi_m], solution[i_e_sw], solution[i_p_L_m],
222  solution.template segment<kelvin_vector_size>(i_sigma_sw)};
223 }
#define OGS_FATAL(...)
Definition: Error.h:26
std::optional< int > solve(JacobianMatrix &jacobian) const
Definition: NewtonRaphson.h:56
std::array< VariableType, static_cast< int >(Variable::number_of_variables)> VariableArray
Definition: VariableType.h:108
@ saturation_micro
capillary pressure saturation relationship for microstructure.
Definition: PropertyType.h:84
constexpr int kelvin_vector_dimensions(int const displacement_dim)
Kelvin vector dimensions for given displacement dimension.
Definition: KelvinVector.h:23

References MaterialPropertyLib::capillary_pressure, MathLib::KelvinVector::kelvin_vector_dimensions(), ProcessLib::RichardsMechanics::MicroPorosityParameters::mass_exchange_coefficient, ProcessLib::RichardsMechanics::MicroPorosityParameters::nonlinear_solver_parameters, OGS_FATAL, MaterialPropertyLib::saturation_micro, NumLib::NewtonRaphson< LinearSolver, JacobianMatrix, JacobianMatrixUpdate, ResidualVector, ResidualUpdate, SolutionUpdate >::solve(), and MaterialPropertyLib::swelling_stress_rate.

◆ createLocalAssemblers()

template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void ProcessLib::RichardsMechanics::createLocalAssemblers ( const unsigned  ,
std::vector< MeshLib::Element * > const &  mesh_elements,
NumLib::LocalToGlobalIndexMap const &  dof_table,
const unsigned  shapefunction_order,
std::vector< std::unique_ptr< LocalAssemblerInterface >> &  local_assemblers,
ExtraCtorArgs &&...  extra_ctor_args 
)

Creates local assemblers for each element of the given mesh.

Template Parameters
LocalAssemblerImplementationthe individual local assembler type
LocalAssemblerInterfacethe general local assembler interface
ExtraCtorArgstypes of additional constructor arguments. Those arguments will be passed to the constructor of LocalAssemblerImplementation.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 70 of file CreateLocalAssemblers.h.

77 {
78  DBUG("Create local assemblers.");
79 
80  detail::createLocalAssemblers<GlobalDim, LocalAssemblerImplementation>(
81  dof_table, shapefunction_order, mesh_elements, local_assemblers,
82  std::forward<ExtraCtorArgs>(extra_ctor_args)...);
83 }
void DBUG(char const *fmt, Args const &... args)
Definition: Logging.h:27

References DBUG().

Referenced by ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::initializeConcreteProcess().

◆ createRichardsMechanicsProcess()

template<int DisplacementDim>
std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess ( std::string  name,
MeshLib::Mesh mesh,
std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&  jacobian_assembler,
std::vector< ProcessVariable > const &  variables,
std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &  parameters,
std::optional< ParameterLib::CoordinateSystem > const &  local_coordinate_system,
unsigned const  integration_order,
BaseLib::ConfigTree const &  config,
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &  media 
)
Input File Parameter:
prj__processes__process__type
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__coupling_scheme
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__process_variables
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__process_variables__pressure
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__process_variables__displacement
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__specific_body_force
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__initial_stress
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__micro_porosity
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__micro_porosity__nonlinear_solver
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__micro_porosity__mass_exchange_coefficient
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__mass_lumping
Input File Parameter:
prj__processes__process__RICHARDS_MECHANICS__explicit_hm_coupling_in_unsaturated_zone

Definition at line 56 of file CreateRichardsMechanicsProcess.cpp.

67 {
69  config.checkConfigParameter("type", "RICHARDS_MECHANICS");
70  DBUG("Create RichardsMechanicsProcess.");
71 
72  auto const coupling_scheme =
74  config.getConfigParameterOptional<std::string>("coupling_scheme");
75  const bool use_monolithic_scheme =
76  !(coupling_scheme && (*coupling_scheme == "staggered"));
77 
78  // Process variable.
79 
81  auto const pv_config = config.getConfigSubtree("process_variables");
82 
83  ProcessVariable* variable_p;
84  ProcessVariable* variable_u;
85  std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
86  process_variables;
87  if (use_monolithic_scheme) // monolithic scheme.
88  {
89  auto per_process_variables = findProcessVariables(
90  variables, pv_config,
91  {
92  "pressure",
94  "displacement"});
95  variable_p = &per_process_variables[0].get();
96  variable_u = &per_process_variables[1].get();
97  process_variables.push_back(std::move(per_process_variables));
98  }
99  else // staggered scheme.
100  {
101  using namespace std::string_literals;
102  for (auto const& variable_name : {"pressure"s, "displacement"s})
103  {
104  auto per_process_variables =
105  findProcessVariables(variables, pv_config, {variable_name});
106  process_variables.push_back(std::move(per_process_variables));
107  }
108  variable_p = &process_variables[0][0].get();
109  variable_u = &process_variables[1][0].get();
110  }
111 
112  DBUG("Associate displacement with process variable '{:s}'.",
113  variable_u->getName());
114 
115  if (variable_u->getNumberOfGlobalComponents() != DisplacementDim)
116  {
117  OGS_FATAL(
118  "Number of components of the process variable '{:s}' is different "
119  "from the displacement dimension: got {:d}, expected {:d}",
120  variable_u->getName(),
121  variable_u->getNumberOfGlobalComponents(),
122  DisplacementDim);
123  }
124 
125  DBUG("Associate pressure with process variable '{:s}'.",
126  variable_p->getName());
127  if (variable_p->getNumberOfGlobalComponents() != 1)
128  {
129  OGS_FATAL(
130  "Pressure process variable '{:s}' is not a scalar variable but has "
131  "{:d} components.",
132  variable_p->getName(),
133  variable_p->getNumberOfGlobalComponents());
134  }
135 
136  auto solid_constitutive_relations =
137  MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
138  parameters, local_coordinate_system, config);
139 
140  // Specific body force
141  Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
142  {
143  std::vector<double> const b =
145  config.getConfigParameter<std::vector<double>>(
146  "specific_body_force");
147  if (b.size() != DisplacementDim)
148  {
149  OGS_FATAL(
150  "The size of the specific body force vector does not match the "
151  "displacement dimension. Vector size is {:d}, displacement "
152  "dimension is {:d}",
153  b.size(), DisplacementDim);
154  }
155 
156  std::copy_n(b.data(), b.size(), specific_body_force.data());
157  }
158 
159  auto media_map =
161  DBUG("Check the media properties of RichardsMechanics process ...");
162  checkMPLProperties(media);
163  DBUG("Media properties verified.");
164 
165  // Initial stress conditions
166  auto const initial_stress = ParameterLib::findOptionalTagParameter<double>(
168  config, "initial_stress", parameters,
169  // Symmetric tensor size, 4 or 6, not a Kelvin vector.
171  &mesh);
172 
173  std::optional<MicroPorosityParameters> micro_porosity_parameters;
174  if (auto const micro_porosity_config =
176  config.getConfigSubtreeOptional("micro_porosity"))
177  {
178  micro_porosity_parameters = MicroPorosityParameters{
181  micro_porosity_config->getConfigSubtree("nonlinear_solver")),
183  micro_porosity_config->getConfigParameter<double>(
184  "mass_exchange_coefficient")};
185  }
186 
187  auto const mass_lumping =
189  config.getConfigParameter<bool>("mass_lumping", false);
190 
191  auto const explicit_hm_coupling_in_unsaturated_zone =
193  config.getConfigParameter<bool>(
194  "explicit_hm_coupling_in_unsaturated_zone", false);
195 
196  RichardsMechanicsProcessData<DisplacementDim> process_data{
197  materialIDs(mesh),
198  std::move(media_map),
199  std::move(solid_constitutive_relations),
200  initial_stress,
201  specific_body_force,
202  micro_porosity_parameters,
203  mass_lumping,
204  explicit_hm_coupling_in_unsaturated_zone};
205 
206  SecondaryVariableCollection secondary_variables;
207 
208  ProcessLib::createSecondaryVariables(config, secondary_variables);
209 
210  return std::make_unique<RichardsMechanicsProcess<DisplacementDim>>(
211  std::move(name), mesh, std::move(jacobian_assembler), parameters,
212  integration_order, std::move(process_variables),
213  std::move(process_data), std::move(secondary_variables),
214  use_monolithic_scheme);
215 }
std::unique_ptr< MaterialSpatialDistributionMap > createMaterialSpatialDistributionMap(std::map< int, std::shared_ptr< Medium >> const &media, MeshLib::Mesh const &mesh)
PropertyVector< int > const * materialIDs(Mesh const &mesh)
Definition: Mesh.cpp:258
NewtonRaphsonSolverParameters createNewtonRaphsonSolverParameters(BaseLib::ConfigTree const &config)
void checkMPLProperties(std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
std::vector< std::reference_wrapper< ProcessVariable > > findProcessVariables(std::vector< ProcessVariable > const &variables, BaseLib::ConfigTree const &pv_config, std::initializer_list< std::string > tags)
void createSecondaryVariables(BaseLib::ConfigTree const &config, SecondaryVariableCollection &secondary_variables)

References BaseLib::ConfigTree::checkConfigParameter(), checkMPLProperties(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), NumLib::createNewtonRaphsonSolverParameters(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), ProcessLib::ProcessVariable::getName(), ProcessLib::ProcessVariable::getNumberOfGlobalComponents(), MathLib::KelvinVector::kelvin_vector_dimensions(), MeshLib::materialIDs(), MaterialPropertyLib::name, and OGS_FATAL.

◆ createRichardsMechanicsProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 2 > ( std::string  name,
MeshLib::Mesh mesh,
std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&  jacobian_assembler,
std::vector< ProcessVariable > const &  variables,
std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &  parameters,
std::optional< ParameterLib::CoordinateSystem > const &  local_coordinate_system,
unsigned const  integration_order,
BaseLib::ConfigTree const &  config,
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &  media 
)

◆ createRichardsMechanicsProcess< 3 >()

template std::unique_ptr< Process > ProcessLib::RichardsMechanics::createRichardsMechanicsProcess< 3 > ( std::string  name,
MeshLib::Mesh mesh,
std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&  jacobian_assembler,
std::vector< ProcessVariable > const &  variables,
std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &  parameters,
std::optional< ParameterLib::CoordinateSystem > const &  local_coordinate_system,
unsigned const  integration_order,
BaseLib::ConfigTree const &  config,
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &  media 
)

◆ operator<<()

template<int DisplacementDim>
std::ostream& ProcessLib::RichardsMechanics::operator<< ( std::ostream &  os,
MicroPorosityStateSpace< DisplacementDim > const &  state 
)

Definition at line 43 of file ComputeMicroPorosity.h.

45 {
46  return os << "phi_m: " << state.phi_m << ", "
47  << "e_sw: " << state.e_sw << ", "
48  << "p_L_m: " << state.p_L_m << ", "
49  << "sigma_sw: " << state.sigma_sw.transpose();
50 }

References ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::e_sw, ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::p_L_m, ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::phi_m, and ProcessLib::RichardsMechanics::MicroPorosityStateSpace< DisplacementDim >::sigma_sw.

◆ updateSwellingStressAndVolumetricStrain()

template<int DisplacementDim, typename IPData >
void ProcessLib::RichardsMechanics::updateSwellingStressAndVolumetricStrain ( IPData &  ip_data,
MaterialPropertyLib::Medium const &  medium,
MaterialPropertyLib::Phase const &  solid_phase,
MathLib::KelvinVector::KelvinMatrixType< DisplacementDim > const &  C_el,
double const  rho_LR,
double const  mu,
std::optional< MicroPorosityParameters micro_porosity_parameters,
double const  alpha,
double const  phi,
double const  p_cap_ip,
MPL::VariableArray variables,
MPL::VariableArray variables_prev,
ParameterLib::SpatialPosition const &  x_position,
double const  t,
double const  dt 
)

Definition at line 32 of file RichardsMechanicsFEM-impl.h.

42 {
43  auto const& identity2 = MathLib::KelvinVector::Invariants<
45  DisplacementDim)>::identity2;
46 
47  auto& sigma_sw = ip_data.sigma_sw;
48  auto const& sigma_sw_prev = ip_data.sigma_sw_prev;
49  if (!medium.hasProperty(MPL::PropertyType::saturation_micro))
50  {
51  // If there is swelling, compute it. Update volumetric strain rate,
52  // s.t. it corresponds to the mechanical part only.
53  sigma_sw = sigma_sw_prev;
54  if (solid_phase.hasProperty(MPL::PropertyType::swelling_stress_rate))
55  {
56  using DimMatrix = Eigen::Matrix<double, 3, 3>;
57  auto const sigma_sw_dot =
58  MathLib::KelvinVector::tensorToKelvin<DisplacementDim>(
59  solid_phase
61  .template value<DimMatrix>(variables, variables_prev,
62  x_position, t, dt));
63  sigma_sw += sigma_sw_dot * dt;
64 
65  // !!! Misusing volumetric strain for mechanical volumetric
66  // strain just to update the transport porosity !!!
67  std::get<double>(variables[static_cast<int>(
68  MPL::Variable::volumetric_strain)]) +=
69  identity2.transpose() * C_el.inverse() * sigma_sw;
70  std::get<double>(variables_prev[static_cast<int>(
71  MPL::Variable::volumetric_strain)]) +=
72  identity2.transpose() * C_el.inverse() * sigma_sw_prev;
73  }
74  }
75 
76  // TODO (naumov) saturation_micro must be always defined together with
77  // the micro_porosity_parameters.
78  if (medium.hasProperty(MPL::PropertyType::saturation_micro))
79  {
80  double const phi_M_prev = ip_data.transport_porosity_prev;
81  double const phi_prev = ip_data.porosity_prev;
82  double const phi_m_prev = phi_prev - phi_M_prev;
83  double const p_L_m_prev = ip_data.liquid_pressure_m_prev;
84 
85  auto const S_L_m_prev = ip_data.saturation_m_prev;
86 
87  auto const [delta_phi_m, delta_e_sw, delta_p_L_m, delta_sigma_sw] =
88  computeMicroPorosity<DisplacementDim>(
89  identity2.transpose() * C_el.inverse(), rho_LR, mu,
90  *micro_porosity_parameters, alpha, phi, -p_cap_ip, p_L_m_prev,
91  variables_prev, S_L_m_prev, phi_m_prev, x_position, t, dt,
92  medium.property(MPL::PropertyType::saturation_micro),
93  solid_phase.property(MPL::PropertyType::swelling_stress_rate));
94 
95  auto& phi_M = ip_data.transport_porosity;
96  phi_M = phi - (phi_m_prev + delta_phi_m);
97  variables_prev[static_cast<int>(MPL::Variable::transport_porosity)] =
98  phi_M_prev;
99  variables[static_cast<int>(MPL::Variable::transport_porosity)] = phi_M;
100 
101  auto& p_L_m = ip_data.liquid_pressure_m;
102  p_L_m = p_L_m_prev + delta_p_L_m;
103  { // Update micro saturation.
104  MPL::VariableArray variables_prev;
105  variables_prev[static_cast<int>(
106  MPL::Variable::capillary_pressure)] = -p_L_m_prev;
107  MPL::VariableArray variables;
108  variables[static_cast<int>(MPL::Variable::capillary_pressure)] =
109  -p_L_m;
110 
111  ip_data.saturation_m =
112  medium.property(MPL::PropertyType::saturation_micro)
113  .template value<double>(variables, x_position, t, dt);
114  }
115  sigma_sw = sigma_sw_prev + delta_sigma_sw;
116  }
117 }

References MaterialPropertyLib::alpha, MaterialPropertyLib::capillary_pressure, MaterialPropertyLib::Medium::hasProperty(), MaterialPropertyLib::Phase::hasProperty(), MathLib::KelvinVector::kelvin_vector_dimensions(), MaterialPropertyLib::Medium::property(), MaterialPropertyLib::Phase::property(), MaterialPropertyLib::saturation_micro, MaterialPropertyLib::swelling_stress_rate, and MaterialPropertyLib::transport_porosity.