Detailed Description

Definition at line 30 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.

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

void	postNonLinearSolver (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, 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_prev, int const process_id)
	compute secondary variables for the coupled equations or for output.

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

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

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	updateDeactivatedSubdomains (double const time, const int process_id)

virtual bool	isMonolithicSchemeUsed () 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 &x_prev, 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 &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) final

void	preOutput (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)

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::vector< std::reference_wrapper< ProcessVariable > > > const &	getProcessVariables () const

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

std::vector< std::size_t > const &	getActiveElementIDs () const

SecondaryVariableCollection const &	getSecondaryVariables () const

std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &	getIntegrationPointWriters () 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)

bool	requiresNormalization () const override

Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)

virtual	~SubmeshAssemblySupport ()=default

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().

void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, 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 &x_prev, int const process_id, 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 Attributes inherited from ProcessLib::Process
std::string const	name

Static Public Attributes inherited from ProcessLib::Process
static PROCESSLIB_EXPORT const std::string	constant_one_parameter_name = "constant_one"

Protected Member Functions inherited from ProcessLib::Process
std::vector< NumLib::LocalToGlobalIndexMap const * >	getDOFTables (int const number_of_processes) const

NumLib::Extrapolator &	getExtrapolator () const

NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const

void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)

virtual void	constructDofTable ()

void	constructMonolithicProcessDofTable ()

void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)

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

std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override

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

CellAverageData	cell_average_data_

std::unique_ptr< ProcessLib::AbstractJacobianAssembler >	_jacobian_assembler

VectorMatrixAssembler	_global_assembler

const bool	_use_monolithic_scheme

unsigned const	_integration_order

std::vector< std::unique_ptr< MeshLib::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 &	x_prev,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 206 of file TESProcess.cpp.

{
    DBUG("Assemble TESProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        getActiveElementIDs(), dof_table, t, dt, x, x_prev, 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(), and ProcessLib::Process::getActiveElementIDs().

◆ assembleWithJacobianConcreteProcess()

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

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 223 of file TESProcess.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_table, t, dt, x, x_prev,
        process_id, &b, &Jac);
}

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

◆ 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 386 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 346 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 311 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.

{
    ProcessLib::createLocalAssemblers<TESLocalAssembler>(
        mesh.getDimension(), mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _assembly_params);
 
    initializeSecondaryVariables();
}

References _assembly_params, _local_assemblers, ProcessLib::createLocalAssemblers(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), initializeSecondaryVariables(), and MeshLib::Mesh::isAxiallySymmetric().

◆ initializeSecondaryVariables()

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

private

Definition at line 152 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 53 of file TESProcess.h.

53{ return false; }

◆ postIterationConcreteProcess()

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

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 261 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 253 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 238 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 93 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 91 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 96 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