ProcessLib::Process Class Reference

Detailed Description

Definition at line 38 of file Process.h.

#include <Process.h>

Inheritance diagram for ProcessLib::Process:

Collaboration diagram for ProcessLib::Process:

Public Types
using	NonlinearSolver = NumLib::NonlinearSolverBase
using	TimeDiscretization = NumLib::TimeDiscretization

Public Member Functions
	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)

Public Attributes
std::string const	name

Protected Member Functions
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
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

Private Member Functions
virtual void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order)=0
	Process specific initialization called by initialize(). More...
virtual void	initializeBoundaryConditions ()
virtual void	setInitialConditionsConcreteProcess (std::vector< GlobalVector * > &, double const, int const)
virtual void	preAssembleConcreteProcess (const double, double const, GlobalVector const &)
virtual 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)=0
virtual 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)=0
virtual void	preTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, const int)
virtual void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &, const double, const double, int const)
virtual void	postNonLinearSolverConcreteProcess (GlobalVector const &, GlobalVector const &, const double, double const, int const)
virtual void	preIterationConcreteProcess (const unsigned, GlobalVector const &)
virtual void	computeSecondaryVariableConcrete (double const, double const, std::vector< GlobalVector * > const &, GlobalVector const &, int const)
virtual NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &)
void	initializeExtrapolator ()
void	computeSparsityPattern ()

Private Attributes
std::vector< SourceTermCollection >	_source_term_collections
ExtrapolatorData	_extrapolator_data

Member Typedef Documentation

NonlinearSolver

using ProcessLib::Process::NonlinearSolver = NumLib::NonlinearSolverBase

Definition at line 44 of file Process.h.

TimeDiscretization

using ProcessLib::Process::TimeDiscretization = NumLib::TimeDiscretization

Definition at line 45 of file Process.h.

Constructor & Destructor Documentation

Process()

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
	)

Definition at line 22 of file Process.cpp.

    : name(std::move(name_)),
      _mesh(mesh),
      _secondary_variables(std::move(secondary_variables)),
      _global_assembler(std::move(jacobian_assembler)),
      _use_monolithic_scheme(use_monolithic_scheme),
      _coupled_solutions(nullptr),
      _integration_order(integration_order),
      _process_variables(std::move(process_variables)),
      _boundary_conditions(
          [&](const std::size_t number_of_process_variables)
              -> std::vector<BoundaryConditionCollection>
          {
              std::vector<BoundaryConditionCollection> pcs_BCs;
              pcs_BCs.reserve(number_of_process_variables);
              for (std::size_t i = 0; i < number_of_process_variables; i++)
              {
                  pcs_BCs.emplace_back(BoundaryConditionCollection(parameters));
              }
              return pcs_BCs;
          }(_process_variables.size())),
      _source_term_collections(
          [&](const std::size_t number_of_processes)
              -> std::vector<SourceTermCollection>
          {
              std::vector<SourceTermCollection> pcs_sts;
              pcs_sts.reserve(number_of_processes);
              for (std::size_t i = 0; i < number_of_processes; i++)
              {
                  pcs_sts.emplace_back(SourceTermCollection(parameters));
              }
              return pcs_sts;
          }(_process_variables.size()))
{
}

Member Function Documentation

assemble()

void ProcessLib::Process::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

Definition at line 206 of file Process.cpp.

{
    assert(x.size() == xdot.size());
    for (std::size_t i = 0; i < x.size(); i++)
    {
        MathLib::LinAlg::setLocalAccessibleVector(*x[i]);
        MathLib::LinAlg::setLocalAccessibleVector(*xdot[i]);
    }
 
    assembleConcreteProcess(t, dt, x, xdot, process_id, M, K, b);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
                                                    nullptr);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _source_term_collections[process_id].integrate(t, *x[process_id], b,
                                                   nullptr);
}

References _boundary_conditions, _source_term_collections, assembleConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

assembleConcreteProcess()

virtual void ProcessLib::Process::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  )

privatepure virtual

Implemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::TES::TESProcess, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::HT::HTProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Referenced by assemble().

assembleWithJacobian()

void ProcessLib::Process::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

Definition at line 230 of file Process.cpp.

{
    assert(x.size() == xdot.size());
    for (std::size_t i = 0; i < x.size(); i++)
    {
        MathLib::LinAlg::setLocalAccessibleVector(*x[i]);
        MathLib::LinAlg::setLocalAccessibleVector(*xdot[i]);
    }
 
    assembleWithJacobianConcreteProcess(t, dt, x, xdot, dxdot_dx, dx_dx,
                                        process_id, M, K, b, Jac);
 
    // TODO: apply BCs to Jacobian.
    _boundary_conditions[process_id].applyNaturalBC(t, x, process_id, K, b,
                                                    &Jac);
 
    // the last argument is for the jacobian, nullptr is for a unused jacobian
    _source_term_collections[process_id].integrate(t, *x[process_id], b, &Jac);
}

References _boundary_conditions, _source_term_collections, assembleWithJacobianConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

assembleWithJacobianConcreteProcess()

virtual void ProcessLib::Process::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  )

privatepure virtual

Implemented in ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::TES::TESProcess, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::HT::HTProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Referenced by assembleWithJacobian().

computeSecondaryVariable()

void ProcessLib::Process::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.

Definition at line 411 of file Process.cpp.

{
    for (auto const* solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
    MathLib::LinAlg::setLocalAccessibleVector(x_dot);
 
    computeSecondaryVariableConcrete(t, dt, x, x_dot, process_id);
}

References computeSecondaryVariableConcrete(), and MathLib::LinAlg::setLocalAccessibleVector().

computeSecondaryVariableConcrete()

virtual void ProcessLib::Process::computeSecondaryVariableConcrete ( double const  , double const  , std::vector< GlobalVector * > const &  , GlobalVector const &  , int const    )

inlineprivatevirtual

Reimplemented in ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HeatConduction::HeatConductionProcess, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

Definition at line 266 of file Process.h.

    {
    }

Referenced by computeSecondaryVariable().

computeSparsityPattern()

void ProcessLib::Process::computeSparsityPattern ( )

private

Computes and stores global matrix' sparsity pattern from given DOF-table.

Definition at line 376 of file Process.cpp.

{
    _sparsity_pattern =
        NumLib::computeSparsityPattern(*_local_to_global_index_map, _mesh);
}

References _local_to_global_index_map, _mesh, _sparsity_pattern, and NumLib::computeSparsityPattern().

Referenced by initialize().

constructDofTable()

void ProcessLib::Process::constructDofTable ( )

protectedvirtual

This function is for general cases, in which all equations of the coupled processes have the same number of unknowns. For the general cases with the staggered scheme, all equations of the coupled processes share one DOF table hold by _local_to_global_index_map. Other cases can be considered by overloading this member function in the derived class.

Reimplemented in ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::HeatTransportBHE::HeatTransportBHEProcess.

Definition at line 256 of file Process.cpp.

{
    if (_use_monolithic_scheme)
    {
        constructMonolithicProcessDofTable();
 
        return;
    }
 
    // For staggered scheme:
    const int specified_process_id = 0;
    constructDofTableOfSpecifiedProcessStaggeredScheme(specified_process_id);
}

References _use_monolithic_scheme, constructDofTableOfSpecifiedProcessStaggeredScheme(), and constructMonolithicProcessDofTable().

Referenced by initialize().

constructDofTableOfSpecifiedProcessStaggeredScheme()

void ProcessLib::Process::constructDofTableOfSpecifiedProcessStaggeredScheme ( const int  specified_prosess_id )

protected

Construct the DOF table for a specified process in the staggered scheme, which is stored in the member of this class, _local_to_global_index_map.

Definition at line 303 of file Process.cpp.

{
    // Create single component dof in every of the mesh nodes.
    _mesh_subset_all_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
 
    // Vector of mesh subsets.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
 
    // Vector of the number of variable components
    std::vector<int> vec_var_n_components;
    // Collect the mesh subsets in a vector for each variables' components.
    std::generate_n(std::back_inserter(all_mesh_subsets),
                    _process_variables[specified_process_id][0]
                        .get()
                        .getNumberOfGlobalComponents(),
                    [&]() { return *_mesh_subset_all_nodes; });
 
    // Create a vector of the number of variable components.
    vec_var_n_components.push_back(_process_variables[specified_process_id][0]
                                       .get()
                                       .getNumberOfGlobalComponents());
    _local_to_global_index_map =
        std::make_unique<NumLib::LocalToGlobalIndexMap>(
            std::move(all_mesh_subsets), vec_var_n_components,
            NumLib::ComponentOrder::BY_LOCATION);
 
    assert(_local_to_global_index_map);
}

References _local_to_global_index_map, _mesh, _mesh_subset_all_nodes, _process_variables, NumLib::BY_LOCATION, and MeshLib::Mesh::getNodes().

Referenced by constructDofTable().

constructMonolithicProcessDofTable()

void ProcessLib::Process::constructMonolithicProcessDofTable ( )

protected

Construct the DOF table for the monolithic scheme, which is stored in the member of this class, _local_to_global_index_map.

Definition at line 270 of file Process.cpp.

{
    // Create single component dof in every of the mesh nodes.
    _mesh_subset_all_nodes =
        std::make_unique<MeshLib::MeshSubset>(_mesh, _mesh.getNodes());
 
    // Vector of mesh subsets.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
 
    // Collect the mesh subsets in a vector for the components of each
    // variables.
    for (ProcessVariable const& pv : _process_variables[0])
    {
        std::generate_n(std::back_inserter(all_mesh_subsets),
                        pv.getNumberOfGlobalComponents(),
                        [&]() { return *_mesh_subset_all_nodes; });
    }
 
    // Create a vector of the number of variable components
    std::vector<int> vec_var_n_components;
    transform(cbegin(_process_variables[0]), cend(_process_variables[0]),
              back_inserter(vec_var_n_components),
              [](ProcessVariable const& pv)
              { return pv.getNumberOfGlobalComponents(); });
 
    _local_to_global_index_map =
        std::make_unique<NumLib::LocalToGlobalIndexMap>(
            std::move(all_mesh_subsets), vec_var_n_components,
            NumLib::ComponentOrder::BY_LOCATION);
 
    assert(_local_to_global_index_map);
}

References _local_to_global_index_map, _mesh, _mesh_subset_all_nodes, _process_variables, NumLib::BY_LOCATION, MeshLib::Mesh::getNodes(), and ProcessLib::ProcessVariable::getNumberOfGlobalComponents().

Referenced by constructDofTable().

extrapolateIntegrationPointValuesToNodes()

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

inlinevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 108 of file Process.h.

    {
    }

getDOFTable()

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

inlinevirtual

Reimplemented in ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

Definition at line 137 of file Process.h.

    {
        return *_local_to_global_index_map;
    }

References _local_to_global_index_map.

Referenced by ProcessLib::Output::doOutputAlways(), ProcessLib::Output::doOutputNonlinearIteration(), and setInitialConditions().

getDOFTableForExtrapolatorData()

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

protectedvirtual

Get the address of a LocalToGlobalIndexMap, and the status of its memory. If the LocalToGlobalIndexMap is created as new in this function, the function also returns a true boolean value to let Extrapolator manage the memory by the address returned by this function.

Returns

Address of a LocalToGlobalIndexMap and its memory status.

Reimplemented in ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::HT::HTProcess.

Definition at line 335 of file Process.cpp.

{
    if (_local_to_global_index_map->getNumberOfGlobalComponents() == 1)
    {
        // For single-variable-single-component processes reuse the existing DOF
        // table.
        const bool manage_storage = false;
        return std::make_tuple(_local_to_global_index_map.get(),
                               manage_storage);
    }
 
    // Otherwise construct a new DOF table.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component;
    all_mesh_subsets_single_component.emplace_back(*_mesh_subset_all_nodes);
 
    const bool manage_storage = true;
 
    return std::make_tuple(new NumLib::LocalToGlobalIndexMap(
                               std::move(all_mesh_subsets_single_component),
                               // by location order is needed for output
                               NumLib::ComponentOrder::BY_LOCATION),
                           manage_storage);
}

References _local_to_global_index_map, _mesh_subset_all_nodes, and NumLib::BY_LOCATION.

Referenced by initializeExtrapolator().

getExtrapolator()

NumLib::Extrapolator& ProcessLib::Process::getExtrapolator ( ) const

inlineprotected

Definition at line 185 of file Process.h.

    {
        return _extrapolator_data.getExtrapolator();
    }

References _extrapolator_data, and ProcessLib::ExtrapolatorData::getExtrapolator().

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::extrapolateIntegrationPointValuesToNodes(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::initializeConcreteProcess(), ProcessLib::HT::HTProcess::initializeConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::initializeConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::initializeConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::initializeConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::initializeConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::initializeConcreteProcess(), and ProcessLib::TES::TESProcess::initializeSecondaryVariables().

getFlux()

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

inlinevirtual

Reimplemented in ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::HT::HTProcess, ProcessLib::LiquidFlow::LiquidFlowProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 167 of file Process.h.

    {
        return Eigen::Vector3d{};
    }

Referenced by ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble().

getIntegrationPointWriter()

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

inline

Definition at line 156 of file Process.h.

    {
        if (mesh == _mesh)
        {
            return &_integration_point_writer;
        }
        return nullptr;
    }

References _integration_point_writer, and _mesh.

Referenced by ProcessLib::Output::doOutputAlways(), and ProcessLib::Output::doOutputNonlinearIteration().

getKnownSolutions()

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

inlinefinal

Definition at line 131 of file Process.h.

    {
        return _boundary_conditions[process_id].getKnownSolutions(t, x);
    }

References _boundary_conditions.

getMatrixSpecifications()

MathLib::MatrixSpecifications ProcessLib::Process::getMatrixSpecifications ( const int  process_id ) const

override

Definition at line 182 of file Process.cpp.

{
    auto const& l = *_local_to_global_index_map;
    return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
            &l.getGhostIndices(), &_sparsity_pattern};
}

References _local_to_global_index_map, and _sparsity_pattern.

getMesh()

MeshLib::Mesh& ProcessLib::Process::getMesh ( ) const

inline

Definition at line 143 of file Process.h.

{ return _mesh; }

References _mesh.

Referenced by ProcessLib::Output::addProcess(), ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::createConstraintDirichletBoundaryCondition(), ProcessLib::Output::doOutput(), ProcessLib::Output::doOutputAlways(), ProcessLib::Output::doOutputLastTimestep(), ProcessLib::Output::doOutputNonlinearIteration(), and ProcessLib::HCNonAdvectiveFreeComponentFlowBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::getOrientedSurfaceNormal().

getProcessVariables()

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

inline

Definition at line 145 of file Process.h.

    {
        return _process_variables[process_id];
    }

References _process_variables.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::computeSecondaryVariableConcrete(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::computeSecondaryVariableConcrete(), ProcessLib::LiquidFlow::LiquidFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ComponentTransport::ComponentTransportProcess::computeSecondaryVariableConcrete(), ProcessLib::createConstraintDirichletBoundaryCondition(), ProcessLib::Output::doOutputAlways(), ProcessLib::Output::doOutputNonlinearIteration(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::initializeConcreteProcess(), ProcessLib::HT::HTProcess::initializeConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::initializeConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::initializeConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::initializeConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::initializeConcreteProcess(), ProcessLib::TES::TESProcess::initializeConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::initializeConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::preTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers(), ProcessLib::HT::HTProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers(), ProcessLib::ComponentTransport::ComponentTransportProcess::setInitialConditionsConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation(), and updateDeactivatedSubdomains().

getSecondaryVariables()

SecondaryVariableCollection const& ProcessLib::Process::getSecondaryVariables ( ) const

inline

Definition at line 150 of file Process.h.

    {
        return _secondary_variables;
    }

References _secondary_variables.

Referenced by ProcessLib::Output::doOutputAlways(), and ProcessLib::Output::doOutputNonlinearIteration().

getSingleComponentDOFTable()

NumLib::LocalToGlobalIndexMap const& ProcessLib::Process::getSingleComponentDOFTable ( ) const

inlineprotected

Definition at line 190 of file Process.h.

    {
        return _extrapolator_data.getDOFTable();
    }

References _extrapolator_data, and ProcessLib::ExtrapolatorData::getDOFTable().

Referenced by ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), and ProcessLib::TES::TESProcess::computeVapourPartialPressure().

initialize()

void ProcessLib::Process::initialize

(

)

Definition at line 94 of file Process.cpp.

{
    DBUG("Initialize process.");
 
    DBUG("Construct dof mappings.");
    constructDofTable();
 
    DBUG("Compute sparsity pattern");
    computeSparsityPattern();
 
    DBUG("Initialize the extrapolator");
    initializeExtrapolator();
 
    initializeConcreteProcess(*_local_to_global_index_map, _mesh,
                              _integration_order);
 
    DBUG("Initialize boundary conditions.");
    initializeBoundaryConditions();
}

References _integration_order, _local_to_global_index_map, _mesh, computeSparsityPattern(), constructDofTable(), DBUG(), initializeBoundaryConditions(), initializeConcreteProcess(), and initializeExtrapolator().

initializeBoundaryConditions()

void ProcessLib::Process::initializeBoundaryConditions ( )

privatevirtual

Member function to initialize the boundary conditions for all coupled processes. It is called by initialize().

Reimplemented in ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

Definition at line 81 of file Process.cpp.

{
    // The number of processes is identical to the size of _process_variables,
    // the vector contains variables for different processes. See the
    // documentation of _process_variables.
    const std::size_t number_of_processes = _process_variables.size();
    for (std::size_t pcs_id = 0; pcs_id < number_of_processes; pcs_id++)
    {
        initializeProcessBoundaryConditionsAndSourceTerms(
            *_local_to_global_index_map, pcs_id);
    }
}

References _local_to_global_index_map, _process_variables, and initializeProcessBoundaryConditionsAndSourceTerms().

Referenced by initialize().

initializeConcreteProcess()

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

privatepure virtual

Process specific initialization called by initialize().

Implemented in ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::TES::TESProcess, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::RichardsFlow::RichardsFlowProcess, ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::HT::HTProcess, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::HeatConduction::HeatConductionProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Referenced by initialize().

initializeExtrapolator()

void ProcessLib::Process::initializeExtrapolator ( )

private

Definition at line 359 of file Process.cpp.

{
    NumLib::LocalToGlobalIndexMap* dof_table_single_component;
    bool manage_storage;
 
    std::tie(dof_table_single_component, manage_storage) =
        getDOFTableForExtrapolatorData();
 
    std::unique_ptr<NumLib::Extrapolator> extrapolator(
        new NumLib::LocalLinearLeastSquaresExtrapolator(
            *dof_table_single_component));
 
    // TODO: Later on the DOF table can change during the simulation!
    _extrapolator_data = ExtrapolatorData(
        std::move(extrapolator), dof_table_single_component, manage_storage);
}

References _extrapolator_data, and getDOFTableForExtrapolatorData().

Referenced by initialize().

initializeProcessBoundaryConditionsAndSourceTerms()

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

protected

Initialize the boundary conditions for a single process or coupled processes modelled by the monolithic scheme. It is called by initializeBoundaryConditions().

Definition at line 67 of file Process.cpp.

{
    auto const& per_process_variables = _process_variables[process_id];
    auto& per_process_BCs = _boundary_conditions[process_id];
 
    per_process_BCs.addBCsForProcessVariables(per_process_variables, dof_table,
                                              _integration_order, *this);
 
    auto& per_process_sts = _source_term_collections[process_id];
    per_process_sts.addSourceTermsForProcessVariables(
        per_process_variables, dof_table, _integration_order);
}

References _boundary_conditions, _integration_order, _process_variables, and _source_term_collections.

Referenced by initializeBoundaryConditions().

isMonolithicSchemeUsed()

bool ProcessLib::Process::isMonolithicSchemeUsed ( ) const

inline

Definition at line 102 of file Process.h.

{ return _use_monolithic_scheme; }

References _use_monolithic_scheme.

Referenced by ProcessLib::createConstraintDirichletBoundaryCondition(), ProcessLib::Output::doOutputAlways(), ProcessLib::Output::doOutputNonlinearIteration(), and anonymous_namespace{TimeLoop.cpp}::isMonolithicProcess().

postIteration()

NumLib::IterationResult ProcessLib::Process::postIteration ( GlobalVector const &  x )

final

Definition at line 430 of file Process.cpp.

{
    MathLib::LinAlg::setLocalAccessibleVector(x);
    return postIterationConcreteProcess(x);
}

References postIterationConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

postIterationConcreteProcess()

virtual NumLib::IterationResult ProcessLib::Process::postIterationConcreteProcess ( GlobalVector const &  )

inlineprivatevirtual

Reimplemented in ProcessLib::TES::TESProcess, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, and ProcessLib::HeatTransportBHE::HeatTransportBHEProcess.

Definition at line 275 of file Process.h.

    {
        return NumLib::IterationResult::SUCCESS;
    }

References NumLib::SUCCESS.

Referenced by postIteration().

postNonLinearSolver()

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

Calculates secondary variables, e.g. stress and strain for deformation analysis, only after nonlinear solver being successfully conducted.

Definition at line 402 of file Process.cpp.

{
    MathLib::LinAlg::setLocalAccessibleVector(x);
    MathLib::LinAlg::setLocalAccessibleVector(xdot);
    postNonLinearSolverConcreteProcess(x, xdot, t, dt, process_id);
}

References postNonLinearSolverConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

postNonLinearSolverConcreteProcess()

virtual void ProcessLib::Process::postNonLinearSolverConcreteProcess ( GlobalVector const &  , GlobalVector const &  , const double  , double const  , int const    )

inlineprivatevirtual

Reimplemented in ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, and ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >.

Definition at line 255 of file Process.h.

    {
    }

Referenced by postNonLinearSolver().

postTimestep()

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

Postprocessing after a complete timestep.

Definition at line 392 of file Process.cpp.

{
    for (auto* const solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
    postTimestepConcreteProcess(x, t, delta_t, process_id);
 
    _boundary_conditions[process_id].postTimestep(t, x, process_id);
}

References _boundary_conditions, postTimestepConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

postTimestepConcreteProcess()

virtual void ProcessLib::Process::postTimestepConcreteProcess ( std::vector< GlobalVector * > const &  , const double  , const double  , int const    )

inlineprivatevirtual

Reimplemented in ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >, ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >, ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::LiquidFlow::LiquidFlowProcess, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::HeatTransportBHE::HeatTransportBHEProcess, ProcessLib::ComponentTransport::ComponentTransportProcess, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, and ProcessLib::HT::HTProcess.

Definition at line 247 of file Process.h.

    {
    }

Referenced by postTimestep().

preAssemble()

void ProcessLib::Process::preAssemble ( const double  t, double const  dt, GlobalVector const &  x  )

final

Definition at line 200 of file Process.cpp.

{
    preAssembleConcreteProcess(t, dt, x);
}

References preAssembleConcreteProcess().

preAssembleConcreteProcess()

virtual void ProcessLib::Process::preAssembleConcreteProcess ( const double  , double const  , GlobalVector const &    )

inlineprivatevirtual

Reimplemented in ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >.

Definition at line 221 of file Process.h.

    {
    }

Referenced by preAssemble().

preIteration()

void ProcessLib::Process::preIteration ( const unsigned  iter, GlobalVector const &  x  )

final

Definition at line 424 of file Process.cpp.

{
    MathLib::LinAlg::setLocalAccessibleVector(x);
    preIterationConcreteProcess(iter, x);
}

References preIterationConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

preIterationConcreteProcess()

virtual void ProcessLib::Process::preIterationConcreteProcess ( const unsigned  , GlobalVector const &    )

inlineprivatevirtual

Reimplemented in ProcessLib::TES::TESProcess.

Definition at line 261 of file Process.h.

    {
    }

Referenced by preIteration().

preTimestep()

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

Preprocessing before starting assembly for new timestep.

Definition at line 382 of file Process.cpp.

{
    for (auto* const solution : x)
        MathLib::LinAlg::setLocalAccessibleVector(*solution);
    preTimestepConcreteProcess(x, t, delta_t, process_id);
 
    _boundary_conditions[process_id].preTimestep(t, x, process_id);
}

References _boundary_conditions, preTimestepConcreteProcess(), and MathLib::LinAlg::setLocalAccessibleVector().

preTimestepConcreteProcess()

virtual void ProcessLib::Process::preTimestepConcreteProcess ( std::vector< GlobalVector * > const &  , const double  , const double  , const int    )

inlineprivatevirtual

Reimplemented in ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >, ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >, ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >, ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >, ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess, ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess, and ProcessLib::TES::TESProcess.

Definition at line 239 of file Process.h.

    {
    }

Referenced by preTimestep().

setCoupledSolutionsForStaggeredScheme()

void ProcessLib::Process::setCoupledSolutionsForStaggeredScheme ( CoupledSolutionsForStaggeredScheme *const  coupled_solutions )

inline

Definition at line 94 of file Process.h.

    {
        _coupled_solutions = coupled_solutions;
    }

References _coupled_solutions.

setCoupledTermForTheStaggeredSchemeToLocalAssemblers()

virtual void ProcessLib::Process::setCoupledTermForTheStaggeredSchemeToLocalAssemblers ( int const  )

inlinevirtual

Reimplemented in ProcessLib::HT::HTProcess, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 103 of file Process.h.

    {
    }

setInitialConditions()

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

Definition at line 114 of file Process.cpp.

{
    auto& x = *process_solutions[process_id];
    auto& x_prev = *process_solutions_prev[process_id];
 
    // getDOFTableOfProcess can be overloaded by the specific process.
    auto const& dof_table_of_process = getDOFTable(process_id);
 
    auto const& per_process_variables = _process_variables[process_id];
    for (std::size_t variable_id = 0;
         variable_id < per_process_variables.size();
         variable_id++)
    {
        MathLib::LinAlg::setLocalAccessibleVector(x);
        ParameterLib::SpatialPosition pos;
 
        auto const& pv = per_process_variables[variable_id];
        DBUG("Set the initial condition of variable {:s} of process {:d}.",
             pv.get().getName().data(), process_id);
 
        auto const& ic = pv.get().getInitialCondition();
 
        auto const num_comp = pv.get().getNumberOfGlobalComponents();
 
        for (int component_id = 0; component_id < num_comp; ++component_id)
        {
            auto const& mesh_subset =
                dof_table_of_process.getMeshSubset(variable_id, component_id);
            auto const mesh_id = mesh_subset.getMeshID();
            for (auto const* node : mesh_subset.getNodes())
            {
                MeshLib::Location const l(mesh_id, MeshLib::MeshItemType::Node,
                                          node->getID());
 
                pos.setNodeID(node->getID());
                pos.setCoordinates(*node);
                auto const& ic_value = ic(t, pos);
 
                auto global_index =
                    std::abs(dof_table_of_process.getGlobalIndex(l, variable_id,
                                                                 component_id));
#ifdef USE_PETSC
                // The global indices of the ghost entries of the global
                // matrix or the global vectors need to be set as negative
                // values for equation assembly, however the global indices
                // start from zero. Therefore, any ghost entry with zero
                // index is assigned an negative value of the vector size
                // or the matrix dimension. To assign the initial value for
                // the ghost entries, the negative indices of the ghost
                // entries are restored to zero.
                if (global_index == x.size())
                    global_index = 0;
#endif
                x.set(global_index, ic_value[component_id]);
            }
        }
    }
 
    MathLib::LinAlg::finalizeAssembly(x);
    MathLib::LinAlg::copy(x, x_prev);  // pushState
 
    setInitialConditionsConcreteProcess(process_solutions, t, process_id);
}

References _process_variables, MathLib::LinAlg::copy(), DBUG(), MathLib::LinAlg::finalizeAssembly(), getDOFTable(), MeshLib::Node, ParameterLib::SpatialPosition::setCoordinates(), setInitialConditionsConcreteProcess(), MathLib::LinAlg::setLocalAccessibleVector(), and ParameterLib::SpatialPosition::setNodeID().

setInitialConditionsConcreteProcess()

virtual void ProcessLib::Process::setInitialConditionsConcreteProcess ( std::vector< GlobalVector * > &  , double const  , int const    )

inlineprivatevirtual

Reimplemented in ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess, ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >, ProcessLib::TH2M::TH2MProcess< DisplacementDim >, ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >, ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >, and ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 214 of file Process.h.

    {
    }

Referenced by setInitialConditions().

solveReactionEquation()

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

inlinevirtual

Reimplemented in ProcessLib::ComponentTransport::ComponentTransportProcess.

Definition at line 176 of file Process.h.

    {
    }

updateDeactivatedSubdomains()

void ProcessLib::Process::updateDeactivatedSubdomains	(	double const	time,
		const int	process_id
	)

Definition at line 190 of file Process.cpp.

{
    auto const& variables_per_process = getProcessVariables(process_id);
    for (auto const& variable : variables_per_process)
    {
        variable.get().updateDeactivatedSubdomains(time);
    }
}

References getProcessVariables().

Member Data Documentation

_boundary_conditions

std::vector<BoundaryConditionCollection> ProcessLib::Process::_boundary_conditions

protected

Vector for boundary conditions. For the monolithic scheme or a single process, the size of the vector is one. For the staggered scheme, the size of vector is the number of the coupled processes.

Definition at line 365 of file Process.h.

Referenced by assemble(), assembleWithJacobian(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getKnownSolutions(), initializeProcessBoundaryConditionsAndSourceTerms(), postTimestep(), and preTimestep().

_coupled_solutions

CoupledSolutionsForStaggeredScheme* ProcessLib::Process::_coupled_solutions

protected

Pointer to CoupledSolutionsForStaggeredScheme, which contains the references to the solutions of the coupled processes.

Definition at line 339 of file Process.h.

Referenced by setCoupledSolutionsForStaggeredScheme(), ProcessLib::ComponentTransport::ComponentTransportProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers(), and ProcessLib::HT::HTProcess::setCoupledTermForTheStaggeredSchemeToLocalAssemblers().

_extrapolator_data

ExtrapolatorData ProcessLib::Process::_extrapolator_data

private

Definition at line 373 of file Process.h.

Referenced by getExtrapolator(), getSingleComponentDOFTable(), and initializeExtrapolator().

_global_assembler

VectorMatrixAssembler ProcessLib::Process::_global_assembler

protected

Definition at line 333 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), and ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess().

_integration_order

unsigned const ProcessLib::Process::_integration_order

protected

Order of the integration method for element-wise integration. The Gauss-Legendre integration method and available orders is implemented in MathLib::GaussLegendre.

Definition at line 344 of file Process.h.

Referenced by initialize(), initializeProcessBoundaryConditionsAndSourceTerms(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), and ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess().

_integration_point_writer

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

protected

An optional vector containing descriptions for integration point data output and setting of the integration point initial conditions. The integration point writer are implemented in specific processes.

Definition at line 350 of file Process.h.

Referenced by ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::HydroMechanicsProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::RichardsMechanicsProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::SmallDeformationNonlocalProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::TH2MProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::ThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::ThermoMechanicsProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::ThermoRichardsFlowProcess(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim >::ThermoRichardsMechanicsProcess(), getIntegrationPointWriter(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess().

_local_to_global_index_map

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::Process::_local_to_global_index_map

protected

Definition at line 329 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), computeSparsityPattern(), ProcessLib::TES::TESProcess::computeVapourPartialPressure(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getDOFTable(), getDOFTableForExtrapolatorData(), ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::getDOFTables(), ProcessLib::ComponentTransport::ComponentTransportProcess::getFlux(), ProcessLib::LiquidFlow::LiquidFlowProcess::getFlux(), ProcessLib::HT::HTProcess::getFlux(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::getFlux(), getMatrixSpecifications(), initialize(), initializeBoundaryConditions(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::TES::TESProcess::postIterationConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::preTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::setInitialConditionsConcreteProcess().

_mesh

MeshLib::Mesh& ProcessLib::Process::_mesh

protected

Definition at line 326 of file Process.h.

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), ProcessLib::TES::TESProcess::computeEquilibriumLoading(), ProcessLib::TES::TESProcess::computeRelativeHumidity(), computeSparsityPattern(), ProcessLib::TES::TESProcess::computeVapourPartialPressure(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::createBHEBoundaryConditionTopBottom(), getIntegrationPointWriter(), getMesh(), initialize(), ProcessLib::TES::TESProcess::initializeSecondaryVariables(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), and ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation().

_mesh_subset_all_nodes

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

protected

Definition at line 327 of file Process.h.

Referenced by ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::constructDofTable(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), getDOFTableForExtrapolatorData(), and ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData().

_process_variables

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

protected

Variables used by this process. For the monolithic scheme or a single process, the size of the outer vector is one. For the staggered scheme, the size of the outer vector is the number of the coupled processes.

Definition at line 360 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), constructDofTableOfSpecifiedProcessStaggeredScheme(), constructMonolithicProcessDofTable(), ProcessLib::ComponentTransport::ComponentTransportProcess::extrapolateIntegrationPointValuesToNodes(), getProcessVariables(), initializeBoundaryConditions(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), initializeProcessBoundaryConditionsAndSourceTerms(), and setInitialConditions().

_secondary_variables

SecondaryVariableCollection ProcessLib::Process::_secondary_variables

protected

Definition at line 331 of file Process.h.

Referenced by getSecondaryVariables(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::initializeConcreteProcess(), ProcessLib::HT::HTProcess::initializeConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::initializeConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::initializeConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::initializeConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::initializeConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::initializeConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::initializeConcreteProcess(), and ProcessLib::TES::TESProcess::initializeSecondaryVariables().

_source_term_collections

std::vector<SourceTermCollection> ProcessLib::Process::_source_term_collections

private

Vector for nodal source term collections. For the monolithic scheme or a single process, the size of the vector is one. For the staggered scheme, the size of vector is the number of the coupled processes.

Definition at line 371 of file Process.h.

Referenced by assemble(), assembleWithJacobian(), and initializeProcessBoundaryConditionsAndSourceTerms().

_sparsity_pattern

GlobalSparsityPattern ProcessLib::Process::_sparsity_pattern

protected

Definition at line 352 of file Process.h.

Referenced by computeSparsityPattern(), and getMatrixSpecifications().

_use_monolithic_scheme

const bool ProcessLib::Process::_use_monolithic_scheme

protected

Definition at line 335 of file Process.h.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), constructDofTable(), ProcessLib::HT::HTProcess::getDOFTableForExtrapolatorData(), ProcessLib::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::hasMechanicalProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::hasMechanicalProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::hasMechanicalProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::hasMechanicalProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::initializeConcreteProcess(), ProcessLib::HT::HTProcess::initializeConcreteProcess(), isMonolithicSchemeUsed(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), and ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::setInitialConditionsConcreteProcess().

name

std::string const ProcessLib::Process::name

Definition at line 323 of file Process.h.

Referenced by ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::initializeConcreteProcess().

---

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

• ProcessLib/Process.h
• ProcessLib/Process.cpp