Detailed Description

Definition at line 31 of file TESProcess.h.

#include <TESProcess.h>

Inheritance diagram for ProcessLib::TES::TESProcess:

Collaboration diagram for ProcessLib::TES::TESProcess:

Public Member Functions
	TESProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&process_variables, SecondaryVariableCollection &&secondary_variables, BaseLib::ConfigTree const &config)

void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id) override

void	preIterationConcreteProcess (const unsigned iter, GlobalVector const &x) override

NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &x) override

bool	isLinear () const override

Public Member Functions inherited from ProcessLib::Process
	Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)

void	preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
	Preprocessing before starting assembly for new timestep. More...

void	postTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep. More...

void	postNonLinearSolver (GlobalVector const &x, GlobalVector const &xdot, const double t, double const dt, int const process_id)

void	preIteration (const unsigned iter, GlobalVector const &x) final

void	computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_dot, int const process_id)
	compute secondary variables for the coupled equations or for output. More...

NumLib::IterationResult	postIteration (GlobalVector const &x) final

void	initialize ()

void	setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)

MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override

void	setCoupledSolutionsForStaggeredScheme (CoupledSolutionsForStaggeredScheme *const coupled_solutions)

void	updateDeactivatedSubdomains (double const time, const int process_id)

bool	isMonolithicSchemeUsed () const

virtual void	setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int const)

virtual void	extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)

void	preAssemble (const double t, double const dt, GlobalVector const &x) final

void	assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) final

void	assembleWithJacobian (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) final

std::vector< NumLib::IndexValueVector< GlobalIndexType > > const *	getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final

virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const

MeshLib::Mesh &	getMesh () const

std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const

SecondaryVariableCollection const &	getSecondaryVariables () const

std::vector< std::unique_ptr< IntegrationPointWriter > > const *	getIntegrationPointWriter (MeshLib::Mesh const &mesh) const

virtual Eigen::Vector3d	getFlux (std::size_t, MathLib::Point3d const &, double const, std::vector< GlobalVector * > const &) const

virtual void	solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)

Private Member Functions
void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
	Process specific initialization called by initialize(). More...

void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) override

void	initializeSecondaryVariables ()

void	assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) override

GlobalVector const &	computeVapourPartialPressure (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)

GlobalVector const &	computeRelativeHumidity (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)

GlobalVector const &	computeEquilibriumLoading (const double t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, std::unique_ptr< GlobalVector > &result_cache)

Private Attributes
std::vector< std::unique_ptr< TESLocalAssemblerInterface > >	_local_assemblers

AssemblyParams	_assembly_params

std::unique_ptr< GlobalVector >	_x_previous_timestep

Additional Inherited Members
Public Types inherited from ProcessLib::Process
using	NonlinearSolver = NumLib::NonlinearSolverBase

using	TimeDiscretization = NumLib::TimeDiscretization

Public Attributes inherited from ProcessLib::Process
std::string const	name

Protected Member Functions inherited from ProcessLib::Process
NumLib::Extrapolator &	getExtrapolator () const

NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const

void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id)

virtual void	constructDofTable ()

void	constructMonolithicProcessDofTable ()

void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_prosess_id)

virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const

Protected Attributes inherited from ProcessLib::Process
MeshLib::Mesh &	_mesh

std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_all_nodes

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map

SecondaryVariableCollection	_secondary_variables

VectorMatrixAssembler	_global_assembler

const bool	_use_monolithic_scheme

CoupledSolutionsForStaggeredScheme *	_coupled_solutions

unsigned const	_integration_order

std::vector< std::unique_ptr< IntegrationPointWriter > >	_integration_point_writer

GlobalSparsityPattern	_sparsity_pattern

std::vector< std::vector< std::reference_wrapper< ProcessVariable > > >	_process_variables

std::vector< BoundaryConditionCollection >	_boundary_conditions

Constructor & Destructor Documentation

◆ TESProcess()

ProcessLib::TES::TESProcess::TESProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	integration_order,
		std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&	process_variables,
		SecondaryVariableCollection &&	secondary_variables,
		BaseLib::ConfigTree const &	config
	)

Input File Parameter:: prj__processes__process__TES__fluid_specific_heat_source

Input File Parameter:: prj__processes__process__TES__fluid_specific_isobaric_heat_capacity

Input File Parameter:: prj__processes__process__TES__solid_specific_heat_source

Input File Parameter:: prj__processes__process__TES__solid_heat_conductivity

Input File Parameter:: prj__processes__process__TES__solid_specific_isobaric_heat_capacity

Input File Parameter:: prj__processes__process__TES__tortuosity

Input File Parameter:: prj__processes__process__TES__diffusion_coefficient

Input File Parameter:: prj__processes__process__TES__porosity

Input File Parameter:: prj__processes__process__TES__solid_density_dry

Input File Parameter:: prj__processes__process__TES__solid_density_initial

Input File Parameter:: special OGS input file parameter

Input File Parameter:: prj__processes__process__TES__characteristic_pressure

Input File Parameter:: prj__processes__process__TES__characteristic_temperature

Input File Parameter:: prj__processes__process__TES__characteristic_vapour_mass_fraction

Input File Parameter:: special OGS input file parameter

Input File Parameter:: prj__processes__process__TES__solid_hydraulic_permeability

Input File Parameter:: prj__processes__process__TES__reactive_system

Input File Parameter:: prj__processes__process__TES__output_element_matrices

Definition at line 20 of file TESProcess.cpp.

     : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables))
 {
     DBUG("Create TESProcess.");
  
     // physical parameters for local assembly
     {
         std::vector<std::pair<std::string, double*>> params{
             {"fluid_specific_heat_source",
              &_assembly_params.fluid_specific_heat_source},
             {"fluid_specific_isobaric_heat_capacity", &_assembly_params.cpG},
             {"solid_specific_heat_source",
              &_assembly_params.solid_specific_heat_source},
             {"solid_heat_conductivity", &_assembly_params.solid_heat_cond},
             {"solid_specific_isobaric_heat_capacity", &_assembly_params.cpS},
             {"tortuosity", &_assembly_params.tortuosity},
             {"diffusion_coefficient",
              &_assembly_params.diffusion_coefficient_component},
             {"porosity", &_assembly_params.poro},
             {"solid_density_dry", &_assembly_params.rho_SR_dry},
             {"solid_density_initial", &_assembly_params.initial_solid_density}};
  
         for (auto const& p : params)
         {
             if (auto const par =
                 config.getConfigParameterOptional<double>(p.first))
             {
                 DBUG("setting parameter `{:s}' to value `{:g}'", p.first, *par);
                 *p.second = *par;
             }
         }
     }
  
     // characteristic values of primary variables
     {
         std::vector<std::pair<std::string, Trafo*>> const params{
             {"characteristic_pressure", &_assembly_params.trafo_p},
             {"characteristic_temperature", &_assembly_params.trafo_T},
             {"characteristic_vapour_mass_fraction", &_assembly_params.trafo_x}};
  
         for (auto const& p : params)
         {
             if (auto const par =
                 config.getConfigParameterOptional<double>(p.first))
             {
                 INFO("setting parameter `{:s}' to value `{:g}'", p.first, *par);
                 *p.second = Trafo{*par};
             }
         }
     }
  
     // permeability
     if (auto par =
         config.getConfigParameterOptional<double>(
             "solid_hydraulic_permeability"))
     {
         DBUG(
             "setting parameter `solid_hydraulic_permeability' to isotropic "
             "value `{:g}'",
             *par);
         const auto dim = mesh.getDimension();
         _assembly_params.solid_perm_tensor =
             Eigen::MatrixXd::Identity(dim, dim) * (*par);
     }
  
     // reactive system
     _assembly_params.react_sys = Adsorption::AdsorptionReaction::newInstance(
         config.getConfigSubtree("reactive_system"));
  
     // debug output
     if (auto const param =
         config.getConfigParameterOptional<bool>("output_element_matrices"))
     {
         DBUG("output_element_matrices: {:s}", (*param) ? "true" : "false");
  
         _assembly_params.output_element_matrices = *param;
     }
  
     // TODO somewhere else
     /*
     if (auto const param =
     config.getConfigParameterOptional<bool>("output_global_matrix"))
     {
         DBUG("output_global_matrix: {:s}", (*param) ? "true" : "false");
  
         this->_process_output.output_global_matrix = *param;
     }
     */
 }

Member Function Documentation

◆ assembleConcreteProcess()

void ProcessLib::TES::TESProcess::assembleConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 212 of file TESProcess.cpp.

 {
     DBUG("Assemble TESProcess.");
  
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_table = {std::ref(*_local_to_global_index_map)};
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
         pv.getActiveElementIDs(), dof_table, t, dt, x, xdot, process_id, M, K,
         b);
 }

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::Process::getProcessVariables().

◆ assembleWithJacobianConcreteProcess()

void ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		const double	dxdot_dx,
		const double	dx_dx,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b,
		GlobalMatrix &	Jac
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 231 of file TESProcess.cpp.

 {
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_table = {std::ref(*_local_to_global_index_map)};
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
         _local_assemblers, pv.getActiveElementIDs(), dof_table, t, dt, x, xdot,
         dxdot_dx, dx_dx, process_id, M, K, b, Jac);
 }

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::Process::getProcessVariables().

◆ computeEquilibriumLoading()

GlobalVector const & ProcessLib::TES::TESProcess::computeEquilibriumLoading	(	const double	t,
		std::vector< GlobalVector * > const &	x,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_table,
		std::unique_ptr< GlobalVector > &	result_cache
	)

private

Definition at line 396 of file TESProcess.cpp.

 {
     constexpr int process_id = 0;  // monolithic scheme.
     assert(dof_table[process_id] == _local_to_global_index_map.get());
  
     auto const& dof_table_single = getSingleComponentDOFTable();
     result_cache = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
         {dof_table_single.dofSizeWithoutGhosts(),
          dof_table_single.dofSizeWithoutGhosts(),
          &dof_table_single.getGhostIndices(), nullptr});
  
     GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
  
     auto const& x = *xs[0];  // monolithic process
     for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
     {
         auto const p = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
                                              node_id, COMPONENT_ID_PRESSURE);
         auto const T = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
                                              node_id, COMPONENT_ID_TEMPERATURE);
         auto const x_mV =
             NumLib::getNodalValue(x, _mesh, *dof_table[process_id], node_id,
                                   COMPONENT_ID_MASS_FRACTION);
  
         auto const x_nV = Adsorption::AdsorptionReaction::getMolarFraction(
             x_mV, _assembly_params.M_react, _assembly_params.M_inert);
  
         auto const p_V = p * x_nV;
         auto const C_eq =
             (p_V <= 0.0) ? 0.0
                          : _assembly_params.react_sys->getEquilibriumLoading(
                                p_V, T, _assembly_params.M_react);
  
         result_cache->set(node_id, C_eq);
     }
  
     return *result_cache;
 }

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, ProcessLib::TES::COMPONENT_ID_TEMPERATURE, Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, ProcessLib::TES::AssemblyParams::M_react, and ProcessLib::TES::AssemblyParams::react_sys.

Referenced by initializeSecondaryVariables().

◆ computeRelativeHumidity()

GlobalVector const & ProcessLib::TES::TESProcess::computeRelativeHumidity	(	const double	t,
		std::vector< GlobalVector * > const &	x,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_table,
		std::unique_ptr< GlobalVector > &	result_cache
	)

private

Definition at line 356 of file TESProcess.cpp.

 {
     constexpr int process_id = 0;  // monolithic scheme.
     assert(dof_table[process_id] == _local_to_global_index_map.get());
  
     auto const& dof_table_single = getSingleComponentDOFTable();
     result_cache = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
         {dof_table_single.dofSizeWithoutGhosts(),
          dof_table_single.dofSizeWithoutGhosts(),
          &dof_table_single.getGhostIndices(), nullptr});
  
     GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
  
     auto const& x = *xs[0];  // monolithic process
     for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
     {
         auto const p = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
                                              node_id, COMPONENT_ID_PRESSURE);
         auto const T = NumLib::getNodalValue(x, _mesh, *dof_table[process_id],
                                              node_id, COMPONENT_ID_TEMPERATURE);
         auto const x_mV =
             NumLib::getNodalValue(x, _mesh, *dof_table[process_id], node_id,
                                   COMPONENT_ID_MASS_FRACTION);
  
         auto const x_nV = Adsorption::AdsorptionReaction::getMolarFraction(
             x_mV, _assembly_params.M_react, _assembly_params.M_inert);
  
         auto const p_S =
             Adsorption::AdsorptionReaction::getEquilibriumVapourPressure(T);
  
         result_cache->set(node_id, p * x_nV / p_S);
     }
  
     return *result_cache;
 }

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, ProcessLib::TES::COMPONENT_ID_TEMPERATURE, Adsorption::AdsorptionReaction::getEquilibriumVapourPressure(), Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, and ProcessLib::TES::AssemblyParams::M_react.

Referenced by initializeSecondaryVariables().

◆ computeVapourPartialPressure()

GlobalVector const & ProcessLib::TES::TESProcess::computeVapourPartialPressure	(	const double	t,
		std::vector< GlobalVector * > const &	x,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_table,
		std::unique_ptr< GlobalVector > &	result_cache
	)

private

Definition at line 321 of file TESProcess.cpp.

 {
     constexpr int process_id = 0;  // monolithic scheme.
     assert(dof_table[process_id] == _local_to_global_index_map.get());
  
     auto const& dof_table_single = getSingleComponentDOFTable();
     result_cache = MathLib::MatrixVectorTraits<GlobalVector>::newInstance(
         {dof_table_single.dofSizeWithoutGhosts(),
          dof_table_single.dofSizeWithoutGhosts(),
          &dof_table_single.getGhostIndices(), nullptr});
  
     GlobalIndexType const nnodes = _mesh.getNumberOfNodes();
  
     for (GlobalIndexType node_id = 0; node_id < nnodes; ++node_id)
     {
         auto const p =
             NumLib::getNodalValue(*x[process_id], _mesh, *dof_table[process_id],
                                   node_id, COMPONENT_ID_PRESSURE);
         auto const x_mV =
             NumLib::getNodalValue(*x[process_id], _mesh, *dof_table[process_id],
                                   node_id, COMPONENT_ID_MASS_FRACTION);
  
         auto const x_nV = Adsorption::AdsorptionReaction::getMolarFraction(
             x_mV, _assembly_params.M_react, _assembly_params.M_inert);
  
         result_cache->set(node_id, p * x_nV);
     }
  
     return *result_cache;
 }

References _assembly_params, ProcessLib::Process::_local_to_global_index_map, ProcessLib::Process::_mesh, ProcessLib::TES::COMPONENT_ID_MASS_FRACTION, ProcessLib::TES::COMPONENT_ID_PRESSURE, Adsorption::AdsorptionReaction::getMolarFraction(), NumLib::getNodalValue(), MeshLib::Mesh::getNumberOfNodes(), ProcessLib::Process::getSingleComponentDOFTable(), ProcessLib::TES::AssemblyParams::M_inert, and ProcessLib::TES::AssemblyParams::M_react.

Referenced by initializeSecondaryVariables().

◆ initializeConcreteProcess()

void ProcessLib::TES::TESProcess::initializeConcreteProcess	(	NumLib::LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh,
		unsigned const	integration_order
	)

overrideprivatevirtual

Process specific initialization called by initialize().

Implements ProcessLib::Process.

Definition at line 140 of file TESProcess.cpp.

 {
     const int monolithic_process_id = 0;
     ProcessLib::ProcessVariable const& pv =
         getProcessVariables(monolithic_process_id)[0];
     ProcessLib::createLocalAssemblers<TESLocalAssembler>(
         mesh.getDimension(), mesh.getElements(), dof_table,
         pv.getShapeFunctionOrder(), _local_assemblers,
         mesh.isAxiallySymmetric(), integration_order, _assembly_params);
  
     initializeSecondaryVariables();
 }

References _assembly_params, _local_assemblers, MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), ProcessLib::Process::getProcessVariables(), ProcessLib::ProcessVariable::getShapeFunctionOrder(), initializeSecondaryVariables(), and MeshLib::Mesh::isAxiallySymmetric().

◆ initializeSecondaryVariables()

void ProcessLib::TES::TESProcess::initializeSecondaryVariables ( )

private

Definition at line 155 of file TESProcess.cpp.

 {
     // adds a secondary variables to the collection of all secondary variables.
     auto add2nd =
         [&](std::string const& var_name, SecondaryVariableFunctions&& fcts)
     { _secondary_variables.addSecondaryVariable(var_name, std::move(fcts)); };
  
     // creates an extrapolator
     auto makeEx =
         [&](unsigned const n_components,
             std::vector<double> const& (TESLocalAssemblerInterface::*method)(
                 const double /*t*/,
                 std::vector<GlobalVector*> const& /*x*/,
                 std::vector<
                     NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
                 std::vector<double>& /*cache*/)
                 const) -> SecondaryVariableFunctions
     {
         return ProcessLib::makeExtrapolator(n_components, getExtrapolator(),
                                             _local_assemblers, method);
     };
  
     add2nd("solid_density",
            makeEx(1, &TESLocalAssemblerInterface::getIntPtSolidDensity));
  
     add2nd("reaction_rate",
            makeEx(1, &TESLocalAssemblerInterface::getIntPtReactionRate));
  
     add2nd("darcy_velocity",
            makeEx(_mesh.getDimension(),
                   &TESLocalAssemblerInterface::getIntPtDarcyVelocity));
  
     add2nd("loading", makeEx(1, &TESLocalAssemblerInterface::getIntPtLoading));
     add2nd(
         "reaction_damping_factor",
         makeEx(1, &TESLocalAssemblerInterface::getIntPtReactionDampingFactor));
  
     add2nd("vapour_partial_pressure",
            {1,
             [&](auto&&... args) -> GlobalVector const& {
                 return computeVapourPartialPressure(args...);
             },
             nullptr});
     add2nd("relative_humidity",
            {1,
             [&](auto&&... args) -> GlobalVector const& {
                 return computeRelativeHumidity(args...);
             },
             nullptr});
     add2nd("equilibrium_loading",
            {1,
             [&](auto&&... args) -> GlobalVector const& {
                 return computeEquilibriumLoading(args...);
             },
             nullptr});
 }

References _local_assemblers, ProcessLib::Process::_mesh, ProcessLib::Process::_secondary_variables, ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), computeEquilibriumLoading(), computeRelativeHumidity(), computeVapourPartialPressure(), MeshLib::Mesh::getDimension(), ProcessLib::Process::getExtrapolator(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtDarcyVelocity(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtLoading(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtReactionDampingFactor(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtReactionRate(), ProcessLib::TES::TESLocalAssemblerInterface::getIntPtSolidDensity(), and ProcessLib::makeExtrapolator().

Referenced by initializeConcreteProcess().

◆ isLinear()

bool ProcessLib::TES::TESProcess::isLinear ( ) const

inlineoverride

Definition at line 54 of file TESProcess.h.

54 { return false; }

◆ postIterationConcreteProcess()

NumLib::IterationResult ProcessLib::TES::TESProcess::postIterationConcreteProcess ( GlobalVector const & x )

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 271 of file TESProcess.cpp.

 {
     bool check_passed = true;
  
     if (!Trafo::constrained)
     {
         // bounds checking only has to happen if the vapour mass fraction is
         // non-logarithmic.
  
         std::vector<GlobalIndexType> indices_cache;
         std::vector<double> local_x_cache;
         std::vector<double> local_x_prev_ts_cache;
  
         MathLib::LinAlg::setLocalAccessibleVector(*_x_previous_timestep);
  
         auto check_variable_bounds =
             [&](std::size_t id, TESLocalAssemblerInterface& loc_asm)
         {
             auto const r_c_indices = NumLib::getRowColumnIndices(
                 id, *this->_local_to_global_index_map, indices_cache);
             local_x_cache = x.get(r_c_indices.rows);
             local_x_prev_ts_cache = _x_previous_timestep->get(r_c_indices.rows);
  
             if (!loc_asm.checkBounds(local_x_cache, local_x_prev_ts_cache))
             {
                 check_passed = false;
             }
         };
  
         GlobalExecutor::executeDereferenced(check_variable_bounds,
                                             _local_assemblers);
     }
  
     if (!check_passed)
     {
         return NumLib::IterationResult::REPEAT_ITERATION;
     }
  
     // TODO remove
     DBUG("ts {:d} iteration {:d} (in current ts: {:d}) try {:d} accepted",
          _assembly_params.timestep, _assembly_params.total_iteration,
          _assembly_params.iteration_in_current_timestep,
          _assembly_params.number_of_try_of_iteration);
  
     _assembly_params.number_of_try_of_iteration = 0;
  
     return NumLib::IterationResult::SUCCESS;
 }

References _assembly_params, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _x_previous_timestep, ProcessLib::TrafoScale::constrained, DBUG(), NumLib::SerialExecutor::executeDereferenced(), MathLib::EigenVector::get(), NumLib::getRowColumnIndices(), ProcessLib::TES::AssemblyParams::iteration_in_current_timestep, ProcessLib::TES::AssemblyParams::number_of_try_of_iteration, NumLib::REPEAT_ITERATION, MathLib::LinAlg::setLocalAccessibleVector(), NumLib::SUCCESS, ProcessLib::TES::AssemblyParams::timestep, and ProcessLib::TES::AssemblyParams::total_iteration.

◆ preIterationConcreteProcess()

void ProcessLib::TES::TESProcess::preIterationConcreteProcess	(	const unsigned	iter,
		GlobalVector const &	x
	)

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 263 of file TESProcess.cpp.

 {
     _assembly_params.iteration_in_current_timestep = iter;
     ++_assembly_params.total_iteration;
     ++_assembly_params.number_of_try_of_iteration;
 }

References _assembly_params, ProcessLib::TES::AssemblyParams::iteration_in_current_timestep, ProcessLib::TES::AssemblyParams::number_of_try_of_iteration, and ProcessLib::TES::AssemblyParams::total_iteration.

◆ preTimestepConcreteProcess()

void ProcessLib::TES::TESProcess::preTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	x,
		const double	t,
		const double	delta_t,
		const int	process_id
	)

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 248 of file TESProcess.cpp.

 {
     DBUG("new timestep");
  
     _assembly_params.delta_t = delta_t;
     _assembly_params.current_time = t;
     ++_assembly_params.timestep;  // TODO remove that
  
     _x_previous_timestep =
         MathLib::MatrixVectorTraits<GlobalVector>::newInstance(*x[process_id]);
 }

References _assembly_params, _x_previous_timestep, ProcessLib::TES::AssemblyParams::current_time, DBUG(), ProcessLib::TES::AssemblyParams::delta_t, and ProcessLib::TES::AssemblyParams::timestep.

Member Data Documentation

◆ _assembly_params

AssemblyParams ProcessLib::TES::TESProcess::_assembly_params

private

Definition at line 95 of file TESProcess.h.

Referenced by TESProcess(), computeEquilibriumLoading(), computeRelativeHumidity(), computeVapourPartialPressure(), initializeConcreteProcess(), postIterationConcreteProcess(), preIterationConcreteProcess(), and preTimestepConcreteProcess().

◆ _local_assemblers

std::vector<std::unique_ptr<TESLocalAssemblerInterface> > ProcessLib::TES::TESProcess::_local_assemblers

private

Definition at line 93 of file TESProcess.h.

Referenced by assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), initializeConcreteProcess(), initializeSecondaryVariables(), and postIterationConcreteProcess().

◆ _x_previous_timestep

std::unique_ptr<GlobalVector> ProcessLib::TES::TESProcess::_x_previous_timestep

private

Definition at line 98 of file TESProcess.h.

Referenced by postIterationConcreteProcess(), and preTimestepConcreteProcess().

The documentation for this class was generated from the following files:

ProcessLib/TES/TESProcess.h
ProcessLib/TES/TESProcess.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

◆ TESProcess()

Member Function Documentation

◆ assembleConcreteProcess()

◆ assembleWithJacobianConcreteProcess()

◆ computeEquilibriumLoading()

◆ computeRelativeHumidity()

◆ computeVapourPartialPressure()

◆ initializeConcreteProcess()

◆ initializeSecondaryVariables()

◆ isLinear()

◆ postIterationConcreteProcess()

◆ preIterationConcreteProcess()

◆ preTimestepConcreteProcess()

Member Data Documentation

◆ _assembly_params

◆ _local_assemblers

◆ _x_previous_timestep